windows-server-2003/com/ole32/stg/utils/df2t/w4ctsupp.cxx

//############################################################################
//#
//#   Microsoft Windows
//#   Copyright (C) Microsoft Corporation, 1992 - 1992.
//#   All rights reserved.
//#
//############################################################################
//
//+----------------------------------------------------------------------------
// File: W4CTSUPP.CXX
//
// Contents: Contains support functions for docfile testing
//
// Command line: N/A
//
// Requires: must be linked with program containing function main()
//
// Notes: Compiled to create W4CTSUPP.LIB
//
// Created: RichE March 1992
//-----------------------------------------------------------------------------

#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <direct.h>
#include <ctype.h>
#include <time.h>

#define __CRC32__
#include "w4ctsupp.hxx"

#include <dfdeb.hxx>

//char for separating FAT file name from extension
#define FILE_NAME_SEPARATOR '.'

//global array of interesting file sizes for IStream read/writes
USHORT ausSIZE_ARRAY[] = {0,1,2,255,256,257,511,512,513,2047,2048,2049,4095,4096,4097};

//test logging file pointer
static FILE *fileLogFile = NULL;

//should log be closed after every log write, modified by SetDebugMode()
static BOOL fCloseLogAfterWrite = FALSE;

//test name string for ErrExit and application use
char szTestName[MAX_TEST_NAME_LEN + 1] = "No Test Name Specified";

//random number seed used by test apps
USHORT usRandomSeed = 0;

//routing variable for standard out in tprintf and ErrExit calls
//can be changed from default of DEST_OUT
BYTE bDestOut = DEST_OUT;

//+----------------------------------------------------------------------------
// Function: Allocate, public
//
// Synopsis: allocate memory, exit with error if malloc failes
//
// Arguments: [cbBytesToAllocate] - size of memory block to allocate
//
// Returns: void pointer to block of memory allocated
//
// Created: RichE March 1992
//-----------------------------------------------------------------------------

void *Allocate(size_t cbBytesToAllocate)
{
    void *pvMemPtr;

    pvMemPtr = (void *) malloc(cbBytesToAllocate);
    if(pvMemPtr == NULL)
    {
        ErrExit(DEST_ERR, ERR, "Unable to allocate %u bytes of memory\n",
                cbBytesToAllocate);
    }

    return pvMemPtr;
}

//+----------------------------------------------------------------------------
// Function: MakePath, public
//
// Synopsis: makes a sub-directory at end of specified path
//
// Effects: For each char in pszDirToMake, if it's a '\', make the destination
//          directory at the level accumulated in pszPathBuf, else append
//          the next letter of the dest path to pszPathBuf.  After the loop,
//          attempt to _mkdir a final time (since the path probably won't
//          end with a '\').
//
// Arguments: [pszDirToMake] - full directory path name to make
//
// Returns: TRUE if all directories in path were made OK, otherwise FALSE
//
// Created: RichE January 1992
//-----------------------------------------------------------------------------

BOOL MakePath(char *pszDirToMake)
{
#ifdef DBCS
	char *pszDirToMakeSav = pszDirToMake;
#endif
    char *pcDestPathSoFar;
    char *pszPathBuf;
    int  iRc;

    pszPathBuf = (char *) Allocate(_MAX_PATH + 1);
    pcDestPathSoFar = pszPathBuf;

    //
    //while not at end of path string, if this char is a back slash, make
    //the directory up to the slash.  in either case, copy the next char
    //into the accumulated path buffer.
    //

    while (*pszDirToMake)
    {
        if (*pszDirToMake == '\\')
        {
            *pcDestPathSoFar = NIL;
            iRc = _mkdir(pszPathBuf);
            tprintf(bDestOut, "Trying to make directory %s, returned %d\n",
                    pszPathBuf, iRc);
        }
#ifdef DBCS
 #ifdef _MAC
		if (iskanji (*pszDirToMake)) // iskanji is in dbcsutil.cpp
 #else
		if (IsDBCSLeadbyte (*pszDirToMake))
 #endif
        	*pcDestPathSoFar++ = *pszDirToMake++;
#endif
        *pcDestPathSoFar++ = *pszDirToMake++;
    }

    //
    //if the last char wasn't a back slash, the last part of the path hasn't
    //been made so make it.
    //
#ifdef DBCS
 #ifdef _MAC
	DecLpch (pszDirToMakeSav, pszDirToMake);
 #else
	pszDirToMake = AnsiPrev (pszDirToMakeSav, pszDirToMake);
 #endif // MAC
	if (*pszDirToMake != '\\')
#else
    if (*(--pszDirToMake) != '\\')
#endif
    {
        *pcDestPathSoFar = NIL;
        iRc = _mkdir(pszPathBuf);
        tprintf(bDestOut, "Trying to make directory %s, returned %d\n",
                pszPathBuf, iRc);
    }

    free(pszPathBuf);

    return (iRc == 0) ? TRUE : FALSE;
}



//+----------------------------------------------------------------------------
// Function: SetDebugMode, public
//
// Synopsis: sets debugging mode and program exit control and tprintf routing
//
// Effects: Sets exit control to 'no exit when complete.'  depending upon
//          the char passed, in calls debug macro to set appropriate
//          debug mode.  If no debug is specified, sets program exit
//          control to 'exit when complete' and sets flag to close log
//          file after every log write.  If a debug mode other than
//          none is specified, redirects default output destination to
//          DEST_LOG instead of DEST_OUT.  Also sets capture buffer to
//          unlimited size
//
// Arguments: [DebugMode] - single character representing desired mode
//
// Modifiles: [fCloseLogAfterWrite] - if running in non-debug mode, close
//                                    log file after every write
//
// Created: RichE April 1992
//-----------------------------------------------------------------------------

void SetDebugMode(char DebugMode)
{
    SET_DISPLAY_BUF_SIZE;

    NO_EXIT_WHEN_DONE;

    switch(DebugMode)
    {
    case 'a':
        DEBUG_ALL;
        bDestOut = DEST_LOG;
        break;

    case 'n':
        DEBUG_NONE;
        EXIT_WHEN_DONE;
        //fCloseLogAfterWrite = TRUE;
        break;

    case 'd':
        DEBUG_DOCFILE;
        bDestOut = DEST_LOG;
        break;

    case 'm':
        DEBUG_MSF;
        bDestOut = DEST_LOG;
        break;

    case 'i':
    default:
        DEBUG_INTERNAL_ERRORS;
        bDestOut = DEST_LOG;
        break;

    }
}



//+----------------------------------------------------------------------------
// Function: ErrExit, public
//
// Synopsis: allows error output to any combo of stdout, stderr, and logfile
//
// Effects: depending upon flags passed in, will display (via vfprintf)
//          error output to any combination of stdout, stderr, and a user-
//          supplied log file.  if output destination is a log file,
//          will open the log file if not already open and set
//          all output to the error output destination as well.
//          prints docfile error message based on error code, or
//          generic error message is error is undefined.  prints error
//          return code, prints FAIL message using extern global [szTestName]
//          (defined in calling test) and exits with error code.
//
// Arguments: [bOutputDest] - bit flags specifying where output goes
//                            valid flags defined in W4CTSUPP.HXX
//            [ErrCode] - error code to use in exit() function
//            [fmt] - vfprintf formatting string
//            [...] - parameters to vfprintf function
//
// Created: RichE March 1992
//-----------------------------------------------------------------------------

void ErrExit(BYTE bOutputDest, SCODE ErrCode, char *fmt, ...)
{
    USHORT iErrIndex = 0;

    struct
    {
        SCODE scErrCode;
        char *pszErrMessage;
    } aszErrMessages[] = {S_FALSE,                     "S_FALSE",
                          STG_E_INVALIDFUNCTION,       "STG_E_INVALIDFUNCTION",
                          STG_E_FILENOTFOUND,          "STG_E_FILENOTFOUND",
                          STG_E_TOOMANYOPENFILES,      "STG_E_TOOMANYOPENFILES",
                          STG_E_ACCESSDENIED,          "STG_E_ACCESSDENIED",
                          STG_E_INVALIDHANDLE,         "STG_E_INVALIDHANDLE",
                          STG_E_INSUFFICIENTMEMORY,    "STG_E_INSUFFICIENTMEMORY",
                          STG_E_INVALIDPOINTER,        "STG_E_INVALIDPOINTER",
                          STG_E_NOMOREFILES,           "STG_E_NOMOREFILES",
                          STG_E_WRITEFAULT,            "STG_E_WRITEFAULT",
                          STG_E_READFAULT,             "STG_E_READFAULT",
                          STG_E_LOCKVIOLATION,         "STG_E_LOCKVIOLATION",
                          STG_E_FILEALREADYEXISTS,     "STG_E_FILEALREADYEXISTS",
                          STG_E_INVALIDPARAMETER,      "STG_E_INVALIDPARAMETER",
                          STG_E_MEDIUMFULL,             "STG_E_MEDIUMFULL",
                          STG_E_ABNORMALAPIEXIT,       "STG_E_ABNORMALAPIEXIT",
                          STG_E_INVALIDHEADER,         "STG_E_INVALIDHEADER",
                          STG_E_INVALIDNAME,           "STG_E_INVALIDNAME",
                          STG_E_UNKNOWN,               "STG_E_UNKNOWN",
                          STG_E_UNIMPLEMENTEDFUNCTION, "STG_E_UNIMPLEMENTEDFUNCTION",
                          STG_E_INVALIDFLAG,           "STG_E_INVALIDFLAG",
                          STG_E_INUSE,                 "STG_E_INUSE",
                          STG_E_NOTCURRENT,            "STG_E_NOTCURRENT",
                          STG_E_REVERTED,              "STG_E_REVERTED",
                          STG_S_CONVERTED,             "STG_S_CONVERTED",
                          ERR,                         "GENERIC_ERROR"
                         };

    va_list args;

    va_start(args, fmt);

    //if dest is log file, open log file if not already open
    //and set all output to DEST_ERR as well.
    if (bOutputDest & DEST_LOG)
    {
        bOutputDest |= DEST_ERR;

        if (fileLogFile == NULL)
        {
            LogFile(NULL, LOG_OPEN);
        }

        vfprintf(fileLogFile, fmt, args);

        if (fCloseLogAfterWrite == TRUE)
        {
            LogFile(NULL, LOG_CLOSE);
        }
    }

    if (bOutputDest & DEST_OUT)
    {
        vfprintf(stdout, fmt, args);
    }

    if (bOutputDest & DEST_ERR)
    {
        vfprintf(stderr, fmt, args);
    }

    va_end(args);

    tprintf(bOutputDest, "Return code %lu (0x%08lX), ", ErrCode, ErrCode);

    //lookup error in struct table and print error message
    while (aszErrMessages[iErrIndex].scErrCode != ErrCode)
    {
        if (aszErrMessages[iErrIndex].scErrCode == ERR)
        {
            break;
        }
        else
        {
            iErrIndex++;
        }
    }

    tprintf(bOutputDest, "%s\n", aszErrMessages[iErrIndex].pszErrMessage);

    tprintf(bOutputDest, "FAIL: %s\n", szTestName);

    exit((int) ErrCode);
}



//+----------------------------------------------------------------------------
// Function: tprintf, public
//
// Synopsis: allows output to any combo of stdout, stderr, and logfile
//
// Effects: depending upon flags passed in, will display (via vfprintf)
//          output to any combination of stdout, stderr, and a user-
//          supplied log file.  if output destination is a log file,
//          will open the log file if not already open and set
//          all output to the error output destination as well.
//
// Arguments: [bOutputDest] - bit flags specifying where output goes
//                            valid flags defined in W4CTSUPP.HXX
//            [fmt] - vfprintf formatting string
//            [...] - parameters to vfprintf function
//
// Created: RichE March 1992
//-----------------------------------------------------------------------------

void tprintf(BYTE bOutputDest, char *fmt, ...)
{
    va_list args;

    va_start(args, fmt);

    //if dest is log file, open log file if not already open
    //and set all output to DEST_ERR as well.
    if (bOutputDest & DEST_LOG)
    {
        bOutputDest |= DEST_ERR;

        if (fileLogFile == NULL)
        {
            LogFile(NULL, LOG_OPEN);
        }

        vfprintf(fileLogFile, fmt, args);

        if (fCloseLogAfterWrite == TRUE)
        {
            LogFile(NULL, LOG_CLOSE);
        }
    }

    if (bOutputDest & DEST_OUT)
    {
        vfprintf(stdout, fmt, args);
    }

    if (bOutputDest & DEST_ERR)
    {
        vfprintf(stderr, fmt, args);
    }

    va_end(args);
}



//+----------------------------------------------------------------------------
// Function: LogFile, public
//
// Synopsis: opens or closed specified file for logging via tprintf and errexit
//
// Effects: the specfied file is opened via fopen for logging purposes when
//          [bLogFileAction] = LOG_OPEN and closed for LOG_CLOSE.  The
//          calling application should open the LogFile via a LOG_INIT
//          call which will define the routine to call to ensure that the
//          log file is closed upon completion and set the log file name.
//
// Modifies: [fileLogFile] - the global variable defined at top of this file
//           will contain a pointer to the log file stream on exit.
//
// Arguments: [pszLogFileName] - pathname of file for logging purposes
//            [bLogFileAction] - whether to open or close the log file
//
// Notes: [pszLogReOpenName] is the filename to use for opening the log
//        file.  In non-debug runs, the log file is closed after every
//        log write and re-opened before the next write.
//
// Created: RichE March 1992
//-----------------------------------------------------------------------------

void LogFile(char *pszLogFileName, BYTE bLogFileAction)
{
    static char  *pszLogReOpenName = NULL;
    static BOOL  fFirstInitCall = FALSE;
    char         *pszTestDataDir;

    switch (bLogFileAction)
    {
    case LOG_INIT:
        if (pszLogFileName == NULL)
        {
            ErrExit(DEST_ERR, ERR, "No filename specified for LOG_INIT\n");
        }

        if (fileLogFile != NULL)
        {
            fclose(fileLogFile);
            free(pszLogReOpenName);
        }

        pszLogReOpenName = (char *) Allocate(strlen(pszLogFileName)+1);
        strcpy(pszLogReOpenName, pszLogFileName);

        if (fFirstInitCall == FALSE)
        {
            //register function to call on program exit
            //

            atexit(MakeSureThatLogIsClosed);
            fFirstInitCall = TRUE;

            //
            //change to dir specified by DFDATA env variable, if it's set
            //

            if (pszTestDataDir = getenv("DFDATA"))
            {
                _chdir(pszTestDataDir);
            }
        }

        break;

    case LOG_OPEN:
        if (fileLogFile != NULL)
        {
            ErrExit(DEST_ERR,ERR,"Can't open log file %s, log is already open!",
                    pszLogReOpenName);
        }

        if (pszLogReOpenName == NULL)
        {
            pszLogReOpenName = (char *) Allocate(strlen(LOG_DEFAULT_NAME)+1);
            strcpy(pszLogReOpenName, LOG_DEFAULT_NAME);
        }

        if ((fileLogFile = fopen(pszLogReOpenName, "w")) == NULL)
        {
            ErrExit(DEST_ERR, ERR, "Error opening log file %s\n",
                    pszLogReOpenName);
        }

        break;

    case LOG_CLOSE:
        if (fileLogFile != NULL)
        {
            fflush(fileLogFile);
            fclose(fileLogFile);
        }
        else
        {
            tprintf(DEST_ERR,"Warning: can't close log file %s, log isn't open!",
                   pszLogReOpenName);
        }

        break;

    default:
        ErrExit(DEST_ERR,ERR,"Invalid parameter to LogFile() function!");
    }
}



//+----------------------------------------------------------------------------
// Function: MakeSureThatLogFileIsClosed
//
// Synopsis: closes log file on exit
//
// Effects: immediately flushes all file buffers, and then calls Logfile to
// close the test log file.  upon abnormal exit (GP fault), this saves most
// of the log information.
//
// Created: RichE March 1992
//-----------------------------------------------------------------------------

void MakeSureThatLogIsClosed(void)
{
    //fflush(fileLogFile);
    LogFile(NULL, LOG_CLOSE);

}

//+----------------------------------------------------------------------------
// Function: MakeSingle, public
//
// Synopsis: converts TCHAR string to single character string
//
// Arguments: [pszSingleName] - pointer to TCHAR string
//            [ptcsWideName] - buffer to hold returned single-wide string
//
// Modifies: [pszSingleName] - on exit holds single-wide character string
//
// Created: RichE March 1992
//-----------------------------------------------------------------------------

void MakeSingle(char *pszSingleName, TCHAR *ptcsWideName)
{
#ifdef UNICODE
    USHORT cusBufLen = (tcslen(ptcsWideName)+1) * sizeof(TCHAR);

    if (_fwcstombs(pszSingleName, ptcsWideName, cusBufLen) == -1)
    {
        ErrExit(DEST_LOG, ERR, "Error converting TCHAR string to single wide\n");
    }
#else
    strcpy(pszSingleName, ptcsWideName);
#endif
}



//+----------------------------------------------------------------------------
// Function: MakeWide, public
//
// Synopsis: converts single character string to multi-byte (TCHAR) string
//
// Arguments: [ptcsWideName] - buffer to hold returned TCHAR string
//            [pszSingleName] - pointer to single wide string
//
// Modifies: [ptcsWideName] - on exit holds wide character string
//
// Created: RichE March 1992
//-----------------------------------------------------------------------------

void MakeWide(TCHAR *ptcsWideName, char *pszSingleName)
{
#ifdef UNICODE
    USHORT cusBufLen = (strlen(pszSingleName)+1) * sizeof(TCHAR);

    if (_fmbstowcs(ptcsWideName, pszSingleName, cusBufLen) == -1)
    {
        ErrExit(DEST_LOG, ERR, "Error converting name %s to TCHAR string\n", pszSingleName);
    }
#else
    strcpy(ptcsWideName, pszSingleName);
#endif
}