Windows-Server-2003/sdktools/logerr/logerr.cpp

//+-----------------------------------------------------------------------------
//
// File				logerr.cpp
// 
// Contents			Error and output logging to avoid broken nmake
//					This program reassigns stderr and stdout to two files 
//					named TMPERR and tmpout, executes a given command and
//					appends the error and output messages to logerr.err
//					and logerr.log respectively.
//
//					Returns 1 (which stops the execution of nmake) only if
//					logerr.err is not accesible. All other i/o errors are
//	 				logged to logerr.err.
// 
// Author & Date    adinas  02/18/98 create file
//                  adinas  04/15/98 update to the new bingen's error values
//                  bensont 04/05/00 
//
//-------------------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>

#include <winerror.h>
#include <windows.h>
#include <string.h>
#include "iodll.h"
#include <ntverp.h>


#define LOGFILE            "LOGFILE"	// The exactly string of the system environment variable name
#define ERRFILE            "ERRFILE"	// The exactly string of the system environment variable name
#define TEMPEXT            ".temp"
#define DEFAULT_LOGFILE "logerr.log"	// Default log filename
#define DEFAULT_ERRFILE "logerr.err"	// Default err filename

#define MAX_FNAME_LEN       MAX_PATH     // Maximum length of the log/err filename string
#define MAX_CMD_LEN             2048	 // Maximum length of the command-line string
#define LAST_KNOWN_WRN            11	 // Maximum warning number known by logerr
#define LAST_KNOWN_ERR           130     // Maximum error number known by logerr
#define IODLL_UNKNOWN              1	 // Used for unknown IODLL errors or warning
#define SYSTEM                     1	 // Used for bingen errors with code > LAST_ERROR

CHAR * pszCmdLine = NULL;
CHAR szCommand[MAX_CMD_LEN];
CHAR szLine[MAX_CMD_LEN];

CHAR szLogfile[MAX_FNAME_LEN];  // Log filename, ex "logerr.log"
CHAR szTempLogfile[MAX_FNAME_LEN + 6];  // Temp Log filename, ex "logerr.err.temp"
CHAR szErrfile[MAX_FNAME_LEN];  // Error filename, ex "logerr.err"
CHAR szTempErrfile[MAX_FNAME_LEN + 6];  // Temp Error filename, ex "logerr.err.temp"

FILE *bak_std_out = stdout;		// Backup stdout 
FILE *bak_std_err = stderr;		// Backup stdin

FILE *out_stream = NULL;             // Stream for the new stdout
FILE *out_stream_temp = NULL;             // Stream for the new stdout
FILE *err_stream = NULL;             // Stream for the err file
FILE *err_stream_temp = NULL;        // Stream for the new stderr

int returnval  = 0;             // Return value
DWORD errorlevel = 0;
BOOL Status;
BOOL bReportError = FALSE;
BOOL bBuildCommand = FALSE;


// Define macros for printing
//     fatal error messages (FATAL)  at stderr
//     fatal error messages (SFATAL) in logerr.log and logerr.err
//     error messages       (ERRMSG) in logerr.log and logerr.err
//     error number         (ERRNO)  in logerr.log and logerr.err
//     warning messages     (WRNMSG) in logerr.log
//     no messages          (NOMSG)  in logerr.log

#define FATAL(err,msg) \
fprintf(bak_std_err,"fatal error: %s %s",err,msg); \
returnval=1;

#define SFATAL(err,msg) \
fprintf(bak_std_out,"fatal error: %s %s",err,msg); \
fprintf(bak_std_err,"fatal error: %s %s",err,msg); \
returnval=1;

#define ERRMSG(err,msg)	\
fprintf(stderr,"ERROR %s: %s\n",#err,msg); \
fprintf(stdout,"ERROR %s: %s\n",#err,msg);
	
#define ERRNO(err,msg)	\
fprintf(stderr,"ERROR %d: %s\n",err,msg); \
fprintf(stdout,"ERROR %d: %s\n",err,msg);

#define WRNMSG(wrn,msg) \
fprintf(stdout,"WARNING %s: %s\n",#wrn,msg);

#define WRNNO(wrn,msg) \
fprintf(stdout,"WARNING %d: %s\n",wrn,msg);

#define NOMSG(msg) \
fprintf(stdout,"%s\n",msg);

// Print the command preceeded by ERROR or WARNING
// if errorlevel is non zero.
// Use ReportCmdExit for all commands but bingen.
// For bingen, use ReportBingenExit.
int __cdecl ReportCmdExit( INT errorlevel, CHAR* szCmdline );
int __cdecl ReportBingenExit ( INT errorlevel, CHAR* szCmdline );
int __cdecl ReportBuildExit ( INT errorlevel, CHAR* szCmdline );
int __cdecl ReportRsrcExit ( INT errorlevel, CHAR* szCmdline );

void __cdecl strlower(char *s);
char * __cdecl strnchr(char *s, char c);
int  __cdecl GetEnvVar(char *envvarname, char *valuebuffer, char *defaultvalue, int bufsize);
void __cdecl AppendDump(FILE *Master, CHAR *Transfile, BOOL bLogError);

//+--------------------------------------------------------------
//
// Function: main
//
//---------------------------------------------------------------

int 
__cdecl main(
		int argc,
		char* argv[] )
{
	SSIZE_T len = 0;			// The string length of the first item (command) of the command line

	// PROCESS_INFORMATION piProcInfo;
	// STARTUPINFO siStartInfo;

	// If no argument, print the help.
	if ( argc !=2 ) goto Help;

	pszCmdLine = strnchr(argv[1], ' ');

Help:;
	// Provide help for using the tool, if required
	if ( argc <= 1 ||
			0 == strcmp( argv[1], "/?" ) ||
			0 == strcmp( argv[1], "-?" ) ||
			NULL == pszCmdLine ) {

		fprintf( stderr, "Usage:\tlogerr \"<command line>\"\n");
		fprintf( stderr, "Ex:\tlogerr \"xcopy /vf c:\\tmp\\myfile.txt .\"\n");

		returnval = 1;
		goto Error;
	}

	// Get Environment, LOGFILE, ERRFILE and ComSpec
	if (    (GetEnvVar(LOGFILE, szLogfile, DEFAULT_LOGFILE, MAX_FNAME_LEN) == 0) ||
			(GetEnvVar(ERRFILE, szErrfile, DEFAULT_ERRFILE, MAX_FNAME_LEN) == 0))
		goto Error;

	// Evaluate templog filename
	strcpy(szTempLogfile, szLogfile);
	strcpy(&szTempLogfile[strlen(szTempLogfile)], TEMPEXT);

	// Evaluate temperr filename
	strcpy(szTempErrfile, szErrfile);
	strcpy(&szTempErrfile[strlen(szTempErrfile)], TEMPEXT);

	// Prepare the output / error output file handle

	if ( (out_stream = fopen( szLogfile, "at")) == NULL) {
		FATAL(szLogfile, "Failed to open log file.");
		goto Error;
	}

	if ( (out_stream_temp = freopen(szTempLogfile, "w+t", stdout)) == NULL) {
		FATAL(szTempLogfile, "Failed to open temp error file.");
		goto Error;
	}

	if ( (err_stream = fopen(szErrfile, "a+t")) == NULL) {
		FATAL(szErrfile, "Failed to open error file.");
		goto Error;
	}

	if ( (err_stream_temp = freopen(szTempErrfile, "w+t", stderr)) == NULL) {
		FATAL(szTempErrfile, "Failed to open temp error file.");
		goto Error;
	}

	fseek(out_stream, 0, SEEK_END);
	fseek(err_stream, 0, SEEK_END);


	// Get the argument as command line (pszCmdLine)
	if (strlen(pszCmdLine) >= MAX_CMD_LEN ) { //- default_cmd_len - strlen(buf)
		FATAL(pszCmdLine, "The Full Command is too long !!!");
		goto Error;
	}

	// Get the first word as command (szCommand)
	len = strchr(pszCmdLine, ' ') - pszCmdLine;
	if (len < 0) len = strlen(pszCmdLine);
	if (len >= MAX_CMD_LEN) {
		FATAL(pszCmdLine,"The First Command is too long !!!");
		goto Error;
	}

	// system to execute the program
	strncpy(szCommand, pszCmdLine, len);
	strlower(szCommand);

	errorlevel=system( pszCmdLine );
		if ( strcmp( szCommand, "bingen" ) == 0) 
			bReportError = ReportBingenExit( errorlevel, pszCmdLine );
		else if ( _stricmp( szCommand, "rsrc" ) == 0)
			bReportError = ReportRsrcExit( errorlevel, pszCmdLine );
		else if ( _stricmp( szCommand, "build" ) == 0) {
			bReportError = ReportBuildExit( errorlevel, pszCmdLine );
			bBuildCommand = TRUE;
		} else
			bReportError = ReportCmdExit( errorlevel, pszCmdLine );

	// Temp Error file complete, set to err_stream
	SetStdHandle(STD_ERROR_HANDLE, err_stream);
	if (NULL != err_stream_temp)
		fclose(err_stream_temp);
	else {
		FATAL(szTempErrfile, "Failed to close error file.");
		goto Error;
	}

	// Temp Error file complete, set to err_stream
	SetStdHandle(STD_OUTPUT_HANDLE, out_stream);
	if (NULL != out_stream_temp) 
		fclose(out_stream_temp);
	else {
		FATAL(szTempLogfile, "Failed to close log file.");
		goto Error;
	}
	
	if (bReportError) {
		fprintf(err_stream, "ERROR %d: %s\n", errorlevel, pszCmdLine);
		fprintf(out_stream, "ERROR %d: %s\n", errorlevel, pszCmdLine);
	} else {
		fprintf(out_stream, "%s\n", pszCmdLine);
	}

	AppendDump(out_stream, szTempLogfile, 0);

	if (bBuildCommand)
		AppendDump(out_stream, "Build.log", 0);

	AppendDump(out_stream, szTempErrfile, 1);

	if (bBuildCommand) 
		AppendDump(err_stream, "Build.err", 1);

Error:
	SetStdHandle(STD_ERROR_HANDLE, bak_std_out);
	SetStdHandle(STD_OUTPUT_HANDLE, bak_std_err);

	if (NULL != err_stream)
		fclose(err_stream);
	if (NULL != out_stream)
		fclose(out_stream);

	// Delete the temporary files

	_unlink (szTempErrfile);
	_unlink (szTempLogfile);

	return returnval;

} // main

int
__cdecl ReportBingenExit(
				INT errorlevel,
				CHAR* szCmdline
						 ) {

	int result=FALSE;
    switch (errorlevel) {

    case ERROR_NO_ERROR:
        // NOMSG(szCmdline);
        break;

    case ERROR_RW_NO_RESOURCES:
        WRNMSG(ERROR_RW_NO_RESOURCES,szCmdline);
        break;

    case ERROR_RW_VXD_MSGPAGE:
        WRNMSG(ERROR_RW_VXD_MSGPAGE,szCmdline);
        break;

    case ERROR_IO_CHECKSUM_MISMATCH:
        WRNMSG(ERROR_IO_CHECKSUM_MISMATCH,szCmdline);
        break;

    case ERROR_FILE_CUSTOMRES:
        WRNMSG(ERROR_FILE_CUSTOMRES,szCmdline);
        break;

    case ERROR_FILE_VERSTAMPONLY:
        WRNMSG(ERROR_FILE_VERSTAMPONLY,szCmdline);
        break;

    case ERROR_RET_RESIZED:
        WRNMSG(ERROR_RET_RESIZED,szCmdline);
        break;

    case ERROR_RET_ID_NOTFOUND:
        WRNMSG(ERROR_RET_ID_NOTFOUND,szCmdline);
        break;

    case ERROR_RET_CNTX_CHANGED:
        WRNMSG(ERROR_RET_CNTX_CHANGED,szCmdline);
        break;

    case ERROR_RET_INVALID_TOKEN:
        WRNMSG(ERROR_RET_INVALID_TOKEN,szCmdline);
        break;

    case ERROR_RET_TOKEN_REMOVED:
        WRNMSG(ERROR_RET_TOKEN_REMOVED,szCmdline);
        break;

    case ERROR_RET_TOKEN_MISMATCH:
        WRNMSG(ERROR_RET_TOKEN_MISMATCH,szCmdline);
        break;

    case ERROR_HANDLE_INVALID:
        ERRMSG(ERROR_HANDLE_INVALID,szCmdline);
		result = TRUE;
        break;

    case ERROR_READING_INI:
        ERRMSG(ERROR_READING_INI,szCmdline);
		result = TRUE;
        break;

    case ERROR_NEW_FAILED:
        ERRMSG(ERROR_NEW_FAILED,szCmdline);
		result = TRUE;
        break;

    case ERROR_OUT_OF_DISKSPACE:
        ERRMSG(ERROR_OUT_OF_DISKSPACE,szCmdline);
		result = TRUE;
        break;

    case ERROR_FILE_OPEN:
        ERRMSG(ERROR_FILE_OPEN,szCmdline);
		result = TRUE;
        break;

    case ERROR_FILE_CREATE:
        ERRMSG(ERROR_FILE_CREATE,szCmdline);
		result = TRUE;
        break;

    case ERROR_FILE_INVALID_OFFSET:
        ERRMSG(ERROR_FILE_INVALID_OFFSET,szCmdline);
		result = TRUE;
        break;

    case ERROR_FILE_READ:
        ERRMSG(ERROR_FILE_READ,szCmdline);
		result = TRUE;
        break;

    case ERROR_FILE_WRITE:
        ERRMSG(ERROR_FILE_WRITE,szCmdline);
		result = TRUE;
        break;

    case ERROR_DLL_LOAD:
        ERRMSG(ERROR_DLL_LOAD,szCmdline);
		result = TRUE;
        break;

    case ERROR_DLL_PROC_ADDRESS:
        ERRMSG(ERROR_DLL_PROC_ADDRESS,szCmdline);
		result = TRUE;
        break;

    case ERROR_RW_LOADIMAGE:
        ERRMSG(ERROR_RW_LOADIMAGE,szCmdline);
		result = TRUE;
        break;

    case ERROR_RW_PARSEIMAGE:
        ERRMSG(ERROR_RW_PARSEIMAGE,szCmdline);
		result = TRUE;
        break;

    case ERROR_RW_GETIMAGE:
        ERRMSG(ERROR_RW_GETIMAGE,szCmdline);
		result = TRUE;
        break;

    case ERROR_RW_NOTREADY:
        ERRMSG(ERROR_RW_NOTREADY,szCmdline);
		result = TRUE;
        break;

    case ERROR_RW_BUFFER_TOO_SMALL:
        ERRMSG(ERROR_RW_BUFFER_TOO_SMALL,szCmdline);
		result = TRUE;
        break;

    case ERROR_RW_INVALID_FILE:
        ERRMSG(ERROR_RW_INVALID_FILE,szCmdline);
		result = TRUE;
        break;

    case ERROR_RW_IMAGE_TOO_BIG:
        ERRMSG(ERROR_RW_IMAGE_TOO_BIG,szCmdline);
		result = TRUE;
        break;

    case ERROR_RW_TOO_MANY_LEVELS:
        ERRMSG(ERROR_RW_TOO_MANY_LEVELS,szCmdline);
		result = TRUE;
        break;

    case ERROR_IO_INVALIDITEM:
        ERRMSG(ERROR_IO_INVALIDITEM,szCmdline);
		result = TRUE;
        break;

    case ERROR_IO_INVALIDID:
        ERRMSG(ERROR_IO_INVALIDID,szCmdline);
		result = TRUE;
        break;

    case ERROR_IO_INVALID_DLL:
        ERRMSG(ERROR_IO_INVALID_DLL,szCmdline);
		result = TRUE;
        break;

    case ERROR_IO_TYPE_NOT_SUPPORTED:
        ERRMSG(ERROR_IO_TYPE_NOT_SUPPORTED,szCmdline);
		result = TRUE;
        break;

    case ERROR_IO_INVALIDMODULE:
        ERRMSG(ERROR_IO_INVALIDMODULE,szCmdline);
		result = TRUE;
        break;

    case ERROR_IO_RESINFO_NULL:
        ERRMSG(ERROR_IO_RESINFO_NULL,szCmdline);
		result = TRUE;
        break;

    case ERROR_IO_UPDATEIMAGE:
        ERRMSG(ERROR_IO_UPDATEIMAGE,szCmdline);
		result = TRUE;
        break;

    case ERROR_IO_FILE_NOT_SUPPORTED:
        ERRMSG(ERROR_IO_FILE_NOT_SUPPORTED,szCmdline);
		result = TRUE;
        break;

    case ERROR_FILE_SYMPATH_NOT_FOUND:
        ERRMSG(ERROR_FILE_SYMPATH_NOT_FOUND,szCmdline);
		result = TRUE;
        break;

    case ERROR_FILE_MULTILANG:
        ERRMSG(ERROR_FILE_MULTILANG,szCmdline);
		result = TRUE;
        break;

    case ERROR_IO_SYMBOLFILE_NOT_FOUND:
        ERRMSG(ERROR_IO_SYMBOLFILE_NOT_FOUND,szCmdline);
		result = TRUE;
        break;

    default:
        break;
    };

    if (errorlevel > LAST_KNOWN_WRN && errorlevel <= LAST_WRN) {
        WRNMSG(IODLL_UNKNOWN,szCmdline);
    }
    if (errorlevel > LAST_KNOWN_ERR && errorlevel <= LAST_ERROR) {
		result = TRUE;
        ERRMSG(IODLL_UNKNOWN,szCmdline);
    }
    if (errorlevel > LAST_ERROR) {
		result = TRUE;
        ERRMSG(SYSTEM,szCmdline);
    }

    return result;

} // ReportBingenExit

int
__cdecl ReportCmdExit (
			INT errorlevel,
			CHAR* szCmdline) {

	int result=FALSE;

    switch (errorlevel) {
    case 0:
		// NOMSG(szCmdline);
		break;
    default:
		// ERRNO(errorlevel,szCmdline);
		result = TRUE;
    }
    return result;

} // ReportCmdExit

int
__cdecl ReportRsrcExit(
				INT errorlevel,
				CHAR* szCmdline
						 ) {
	int result=FALSE;

    switch (errorlevel) {

    case 0:
        // NOMSG(szCmdline);
        break;
    case 1:
        WRNNO(1,szCmdline );
        break;
    default:
        ERRNO(errorlevel,szCmdline );
		result = TRUE;
        break;
    } // switch
	return result;
}

int
__cdecl ReportBuildExit(
				INT errorlevel,
				CHAR* szCmdline
						 ) {
	int result=FALSE;

    switch (errorlevel) {

    case 0:
        // NOMSG(szCmdline);
        break;
    default:
        // ERRNO(errorlevel,szCmdline );
		result = TRUE;
        break;
    } // switch
	return result;
}

char * __cdecl strnchr(char *s, char c) {
	while(*s==c);
	return (*s==NULL)?NULL:s;
}


int __cdecl GetEnvVar(char *envvarname, char *valuebuffer, char *defaultvalue, int bufsize) {

	int ret = 0;

	// ret == 0 => undefine ERRFILE, set to default
	// ret > MAX_FNAME_LEN => out of buffersize, set to fatal error
	if ((ret=GetEnvironmentVariable(envvarname, valuebuffer, bufsize)) == 0)
		strcpy(valuebuffer, defaultvalue);
	else if (ret > bufsize) {
		FATAL(envvarname,"The Environment Variable's value is too long!!!");
		return 0;
	}
	return 1;
}

void __cdecl strlower(char *s) {
	while(*s) {
		if(isalpha(*s)) *s|=0x20;
		s++;
	}
}

void __cdecl AppendDump(FILE *Master, CHAR *Transfile, BOOL bLogError) {
	SSIZE_T len = 0;
	FILE *Transaction;

	if ((Transaction=fopen(Transfile, "rt")) == NULL) {
 			return;
	}

	while (fgets(szLine, sizeof(szLine) - sizeof(szLine[0]), Transaction)) {

		// Remove double \n
		for (len = strlen(szLine); --len >=0 && szLine[len] < ' '; szLine[len]=0);

		// Next Line if is empty line
		if (len < 1) continue;

		if (0 != ferror(Transaction)) {
			SFATAL(Transfile,"Unable to open for reading");
			return;
		} // if

		// Write to log file
		fprintf(Master, "\t%s\n", szLine);

		// Write to error file if need
		if (bLogError && bReportError) fprintf(err_stream, "\t%s\n", szLine);
	}

	if( ferror( Transaction ) )      {
		FATAL(pszCmdLine,"Temp error file broken !!!");
	}         

	if (NULL != Transaction)
		fclose(Transaction);
}