ULONG __cdecl
DbgPrintEntry(
    __in PCHAR Format,
	...
	)
{
	PDBG_OUTPUTA Filter;
	PBTR_FILTER_RECORD Record;
	BTR_PROBE_CONTEXT Context;
	DBGPRINT Routine;
	size_t Length;
	ULONG UserLength;
	va_list arg;
	PULONG_PTR Sp;
	ULONG Result;
	char format[512];
	char buffer[512];
	
	BtrFltGetContext(&Context);
	Routine = Context.Destine;

	//
	// N.B. Maximum support 16 arguments
	//

	Sp = (PULONG_PTR)&Format + 1;
	Result = (*Routine)(Format, Sp[0], Sp[1], Sp[2], Sp[3], Sp[4],
			   Sp[5], Sp[6], Sp[7], Sp[8], Sp[9], 
			   Sp[10], Sp[11], Sp[12], Sp[13], Sp[14]);

	BtrFltSetContext(&Context);

	__try {

		va_start(arg, Format);
		StringCchVPrintfA(format, 512, Format, arg);
		StringCchPrintfA(buffer, 512, "%s", format);
		Length = strlen(buffer) + 1;
		va_end(arg);

		UserLength = FIELD_OFFSET(DBG_OUTPUTA, Text[Length]);
		Record = BtrFltAllocateRecord(UserLength, DbgUuid, _DbgPrint);
		if (!Record) {
			return Result;
		}

		Filter = FILTER_RECORD_POINTER(Record, DBG_OUTPUTA);
		Filter->Length = Length;
		StringCchCopyA(Filter->Text, Length, buffer);

		BtrFltQueueRecord(Record);
	}
	__except (EXCEPTION_EXECUTE_HANDLER) {
		if (Record) {
			BtrFltFreeRecord(Record);
		}		
	}

	return Result;
}
Exemple #2
0
void
DbgPrintf(A_INT32 mask, A_CHAR * format, ...)
{
    va_list     argList;    /* holds the arguement list passed in */
    A_CHAR      buffer[1024];
    wchar_t     wBuf[1024];

    if (mask & printMask)
    {
        /* get the argument list */
        va_start (argList, format);

        /*
         * using vprintf to perform the printing it is the same is printf, only
         * it takes a va_list or arguements
         */
        if (S_OK != StringCchVPrintfA (buffer, sizeof (buffer), format, argList))
        {
            return;
        }
        MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, buffer, -1, wBuf, 256 );
        OutputDebugString (wBuf);
    }

    return;
}
__inline void TraceA(const char *format, ...)
{
    if(g_bDebug)
    {
        if (format)
        {
            va_list arglist;
            char str[4096];

            va_start(arglist, format);
            StringCchVPrintfA(str, sizeof(str), format, arglist);
            StringCbCatA(str, sizeof(str), "\n");
            if (g_fLogFile)
            {
                FILE *fout = fopen(g_fLogFile, "a+t");
                if (fout)
                {
                    fprintf(fout, str);
                    fclose(fout);
                }
            }

            printf(str);

            if (g_bDebugString)
            {
                
                OutputDebugStringA(str);
            }

            va_end(arglist);
        }
    }
}
Exemple #4
0
void
logPrintf(A_INT32 mask, A_CHAR * format, ...)
{
    va_list     argList;    /* holds the arguement list passed in */
    A_CHAR      buffer[1024];

    FILE        *fStream = NULL;


    /* get the argument list */
    va_start(argList, format);

    /*
     * using vprintf to perform the printing it is the same is printf, only
     * it takes a va_list or arguements
     */
    if (S_OK != StringCchVPrintfA (buffer, sizeof (buffer), format, argList))
    {
        return;
    }

    fStream = fopen("\\Windows\\ar6khost.log", "a+");

    if (fStream)
    {
        fprintf(fStream,"%i: %s\n",GetTickCount(),buffer);
        fclose(fStream);
    }
    return;
}
Exemple #5
0
//
// warning -- this function is implemented twice for ansi applications
// linking to the unicode library
//
void WINAPI DbgLogInfo(DWORD Type,DWORD Level,__format_string LPCSTR pFormat,...)
{
    /* Check the current level for this type combination */

    BOOL bAccept = DbgCheckModuleLevel(Type,Level);
    if (bAccept == FALSE) {
        return;
    }

    TCHAR szInfo[2000];

    /* Format the variable length parameter list */

    va_list va;
    va_start(va, pFormat);

    (void)StringCchPrintf(szInfo, NUMELMS(szInfo),
             TEXT("%s(tid %x) %8d : "),
             m_ModuleName,
             GetCurrentThreadId(), timeGetTime() - dwTimeOffset);

    CHAR szInfoA[2000];
    WideCharToMultiByte(CP_ACP, 0, szInfo, -1, szInfoA, NUMELMS(szInfoA), 0, 0);

    (void)StringCchVPrintfA(szInfoA + lstrlenA(szInfoA), NUMELMS(szInfoA) - lstrlenA(szInfoA), pFormat, va);
    (void)StringCchCatA(szInfoA, NUMELMS(szInfoA), "\r\n");

    WCHAR wszOutString[2000];
    MultiByteToWideChar(CP_ACP, 0, szInfoA, -1, wszOutString, NUMELMS(wszOutString));
    DbgOutString(wszOutString);

    va_end(va);
}
Exemple #6
0
BOOL WINAPIV LSLogPrintf(int nLevel, LPCSTR pszModule, LPCSTR pszFormat, ...)
{
#if defined(LS_COMPAT_LOGGING)
    if (!pszModule || !pszFormat)
    {
        return FALSE;
    }

    BOOL bReturn = FALSE;
    char szMessage[MAX_LINE_LENGTH];

    va_list argList;
    va_start(argList, pszFormat);

    if (SUCCEEDED(StringCchVPrintfA(szMessage, MAX_LINE_LENGTH,
        pszFormat, argList)))
    {
        bReturn = LSLog(nLevel, pszModule, szMessage);
    }

    va_end(argList);

    return bReturn;
#else
    return TRUE;
#endif // LS_COMPAT_LOGGING
}
Exemple #7
0
VOID
MspWriteLogEntry(
	IN ULONG ProcessId,
	IN MSP_LOG_LEVEL Level,
	IN PSTR Format,
	...
	)
{
	ULONG IsLogging;
	va_list Argument;
	PMSP_LOG_ENTRY Entry;
	CHAR Buffer[MSP_LOG_TEXT_LIMIT];

	IsLogging = InterlockedCompareExchange(&MspLogObject.Flag, 0, 0);
	if (!IsLogging) {
		return;
	}

	va_start(Argument, Format);
	StringCchVPrintfA(Buffer, MAX_PATH, Format, Argument);
	va_end(Argument);

	Entry = (PMSP_LOG_ENTRY)MspMalloc(sizeof(MSP_LOG_ENTRY));
	Entry->ProcessId = ProcessId;

	GetLocalTime(&Entry->TimeStamp);
	StringCchCopyA(Entry->Text, MSP_LOG_TEXT_LIMIT, Buffer);

	EnterCriticalSection(&MspLogObject.Lock);
	InsertTailList(&MspLogObject.ListHead, &Entry->ListEntry);
	MspLogObject.ListDepth += 1;
	LeaveCriticalSection(&MspLogObject.Lock);

	return;
}
Exemple #8
0
/*++

TraceFormat

    Sends the message to a debugger.

Arguments:
    funct   - Pointer to a null-terminated string that specifies the function.

    format  - Pointer to a null-terminated printf-style format string.

    ...     - Arguments to insert into "format".

Return Values:
    None.

--*/
VOID CCALL TraceFormat(const char *funct, const char *format, ...)
{
    char *end;
    char output[1024];
    DWORD error;
    size_t remaining;
    va_list argList;

    ASSERT(funct != NULL);
    ASSERT(format != NULL);

    // Preserve system error code
    error = GetLastError();

    StringCchPrintfExA(output, ELEMENT_COUNT(output), &end, &remaining, 0,
        "| %4d | %17s | ", GetCurrentThreadId(), funct);
    va_start(argList, format);
    StringCchVPrintfA(end, remaining, format, argList);
    va_end(argList);

    OutputDebugStringA(output);

    // Restore system error code
    SetLastError(error);
}
Exemple #9
0
/********************************************************************
StrAnsiAllocFormattedArgs - allocates or reuses dynamic ANSI string memory
and formats it with the passed in args

NOTE: caller is responsible for freeing ppsz even if function fails
********************************************************************/
extern "C" HRESULT DAPI StrAnsiAllocFormattedArgs(
	__inout LPSTR* ppsz,
	__in LPCSTR szFormat,
	__in va_list args
	)
{
	Assert(ppsz && szFormat && *szFormat);

	HRESULT hr = S_OK;
	DWORD_PTR cch = *ppsz ? MemSize(*ppsz) / sizeof(CHAR) : 0;
	LPSTR pszOriginal = NULL;
	DWORD cchOriginal = 0;

	if (*ppsz)
	{
		cch = MemSize(*ppsz);  // get the count in bytes so we can check if it failed (returns -1)
		if (-1 == cch)
			ExitOnFailure(hr = E_INVALIDARG, "failed to get size of destination string");
		cch /= sizeof(CHAR);  //convert the count in bytes to count in characters

		cchOriginal = lstrlenA(*ppsz);
	}

	if (0 == cch)   // if there is no space in the string buffer
	{
		cch = 256;
		hr = StrAnsiAlloc(ppsz, cch);
		ExitOnFailure1(hr, "failed to allocate string to format: %s", szFormat);
	}

	// format the message (grow until it fits or there is a failure)
	do
	{
		hr = StringCchVPrintfA(*ppsz, cch, szFormat, args);
		if (STRSAFE_E_INSUFFICIENT_BUFFER == hr)
		{
			if (!pszOriginal)
			{
				// this allows you to pass the original string as a formatting argument and not crash
				// save the original string and free it after the printf is complete
				pszOriginal = *ppsz;
				*ppsz = NULL;
				// StringCchVPrintfW starts writing to the string...
				// NOTE: this hack only works with sprintf(&pwz, "%s ...", pwz, ...);
				pszOriginal[cchOriginal] = 0;
			}
			cch *= 2;
			hr = StrAnsiAlloc(ppsz, cch);
			ExitOnFailure1(hr, "failed to allocate string to format: %S", szFormat);
			hr = S_FALSE;
		}
	} while (S_FALSE == hr);
	ExitOnFailure(hr, "failed to format string");

LExit:
	ReleaseStr((void*) pszOriginal);
	return hr;
}
Exemple #10
0
/*******************************************************************
Dutil_Trace

*******************************************************************/
extern "C" void DAPI Dutil_Trace(
								 __in LPCSTR szFile,
								 __in int iLine,
								 __in REPORT_LEVEL rl,
								 __in LPCSTR szFormat,
								 ...
								 )
{
	AssertSz(REPORT_NONE != rl, "REPORT_NONE is not a valid tracing level");

	HRESULT hr = S_OK;
	char szOutput[DUTIL_STRING_BUFFER];
	char szMsg[DUTIL_STRING_BUFFER];

	if (Dutil_rlCurrentTrace < rl)
		return;

	va_list args;
	va_start(args, szFormat);
	hr = StringCchVPrintfA(szOutput, countof(szOutput), szFormat, args);
	va_end(args);

	if (SUCCEEDED(hr))
	{
		LPCSTR szPrefix = "Trace/u";
		char szMsg[DUTIL_STRING_BUFFER];
		switch (rl)
		{
		case REPORT_STANDARD:
			szPrefix = "Trace/s";
			break;
		case REPORT_VERBOSE:
			szPrefix = "Trace/v";
			break;
		case REPORT_DEBUG:
			szPrefix = "Trace/d";
			break;
		}

		if (Dutil_fTraceFilenames)
			hr = StringCchPrintfA(szMsg, countof(szMsg), "%s [%s,%d]: %s\r\n", szPrefix, szFile, iLine, szOutput);
		else
			hr = StringCchPrintfA(szMsg, countof(szMsg), "%s: %s\r\n", szPrefix, szOutput);

		if (SUCCEEDED(hr))
			OutputDebugStringA(szMsg);
		// else fall through to the case below
	}

	if (FAILED(hr))
	{
		if (Dutil_fTraceFilenames)
			StringCchPrintfA(szMsg, countof(szMsg), "Trace [%s,%d]: message too long, skipping\r\n", szFile, iLine);
		else
			StringCchPrintfA(szMsg, countof(szMsg), "Trace: message too long, skipping\r\n");
		OutputDebugStringA(szMsg);
	}
}
Exemple #11
0
void iw_vsnprintf(char *buf, size_t buflen, const char *fmt, va_list ap)
{
#ifdef IW_WINDOWS
	StringCchVPrintfA(buf,buflen,fmt,ap);
#else
	vsnprintf(buf,buflen,fmt,ap);
	buf[buflen-1]='\0';
#endif
}
Exemple #12
0
void __cdecl DebugPrintA(__in_z __format_string LPCSTR lpcszFormat, ...) 
{ 
	va_list pArguments; 
	char szDebugBuffer[1024];
	va_start(pArguments, lpcszFormat); 
	if (SUCCEEDED(StringCchVPrintfA(szDebugBuffer, _countof(szDebugBuffer), lpcszFormat, pArguments))) 
		OutputDebugStringA(szDebugBuffer); 
	va_end(pArguments); 
}
Exemple #13
0
/********************************************************************
 WcaLog() - outputs trace and log info

*******************************************************************/
extern "C" void __cdecl WcaLog(
    __in LOGLEVEL llv,
    __in_z __format_string PCSTR fmt, 
    ...
    )
{
    static char szFmt[LOG_BUFFER];
    static char szBuf[LOG_BUFFER];
    static bool fInLogPrint = false;

    // prevent re-entrant logprints.  (recursion issues between assert/logging code)
    if (fInLogPrint)
        return;
    fInLogPrint = true;

    if (LOGMSG_STANDARD == llv || 
        (LOGMSG_VERBOSE == llv && IsVerboseLoggingLite())
#ifdef DEBUG
        || LOGMSG_TRACEONLY == llv
#endif
        )
    {
        va_list args;
        va_start(args, fmt);

        LPCSTR szLogName = WcaGetLogName();
        if (szLogName[0] != 0)
            StringCchPrintfA(szFmt, countof(szFmt), "%s:  %s", szLogName, fmt);
        else
            StringCchCopyA(szFmt, countof(szFmt), fmt);

        StringCchVPrintfA(szBuf, countof(szBuf), szFmt, args);
        va_end(args);

#ifdef DEBUG
        // always write to the log in debug
#else
        if (llv == LOGMSG_STANDARD || (llv == LOGMSG_VERBOSE && IsVerboseLoggingLite()))
#endif
        {
            PMSIHANDLE hrec = MsiCreateRecord(1);

            ::MsiRecordSetStringA(hrec, 0, szBuf);
            // TODO:  Recursion on failure.  May not be safe to assert from here.
            WcaProcessMessage(INSTALLMESSAGE_INFO, hrec);
        }

#if DEBUG
        StringCchCatA(szBuf, countof(szBuf), "\n");
        OutputDebugStringA(szBuf);
#endif
    }

    fInLogPrint = false;
    return;
}
Exemple #14
0
static int debug_outputlnA_impl(const char * formatString, va_list args)
{
	HRESULT hr;
	hr = StringCchVPrintfA(g_outputBuffer, OUTPUT_BUFFER_LEN, formatString, args);
	if (SUCCEEDED(hr) || hr == STRSAFE_E_INSUFFICIENT_BUFFER)
    {
		OutputDebugStringA(g_outputBuffer);
    }
    va_end(args);
	return SUCCEEDED(hr);
}
Exemple #15
0
void DebugMsg(const CHAR* pszFormat, ...)
{
    CHAR buf[1024];
    StringCchPrintfA(buf, sizeof(buf)/sizeof(CHAR), "(%lu): ", GetCurrentThreadId());
		va_list arglist;
		va_start(arglist, pszFormat);
		StringCchVPrintfA(&buf[strlen(buf)], sizeof(buf)/sizeof(CHAR), pszFormat, arglist);
		va_end(arglist);
    StringCchCatA(buf, sizeof(buf)/sizeof(CHAR), "\n");
	OutputDebugStringA(buf);
}
void Trace(LPSTR format, ...)
    {
    char message[256];
    va_list args = NULL;
    va_start(args, format);
    StringCchVPrintfA(message, 256, format, args);

    char buffer[256];
    StringCchCopyA(buffer, 256, "ode: ");
    StringCchCatA(buffer, 256, message);
    OutputDebugStringA(buffer);
    }
Exemple #17
0
static BOOL DebugMessageV(LPCSTR lpszMessage, va_list arglist)
{
    DWORD   dwSize = DEBUG_BUFFER_SIZE;
    LPSTR   lpszMsgBuf = NULL;
    HRESULT hr = S_FALSE;


    // Parameter checking.
    if( (NULL == lpszMessage)
            ||
            (0 == dwSize)
      )
    {
        return FALSE;
    }

    do
    {
        // Allocate memory for message buffer.
        if(NULL != lpszMsgBuf)
        {
            delete[] lpszMsgBuf;
            dwSize *= 2;
        }

        //
        // Just to make sure we dont go into infinite loop and allocate
        // lots of memory, lets bail out if memory requirement becomes huge.
        // Multiplying by 8, i.e. will loop at most 4 times.
        //
        if ( dwSize > 8*DEBUG_BUFFER_SIZE )
        {
            return FALSE;
        }

        lpszMsgBuf = new CHAR[dwSize + 1];
        if(NULL == lpszMsgBuf)
            return FALSE;

        hr = StringCchVPrintfA ( lpszMsgBuf, dwSize, lpszMessage, arglist);
        // Pass the variable parameters to wvsprintf to be formated.
    } while (FAILED (hr) );

    // Dump string to Debug output.
    OutputDebugStringA(lpszMsgBuf);

    // Cleanup.
    delete[] lpszMsgBuf;

    return TRUE;
}
Exemple #18
0
//------------------------------------------------------------------------------
// Function: LuaError
//
// Description:
//
//  Raise a formatted error message.
//  
// Returns:
//
// Notes:
//
//  This function allows more elaborate format specifiers than luaL_error.
//
int
LuaError(
	_In_ lua_State* L,
	_In_z_ const char* fmt,
	...)
{
	char buf[1024];
	va_list arg;
	va_start(arg, fmt);
	StringCchVPrintfA(STRING_AND_CCH(buf), fmt, arg);
	va_end(arg);

	return luaL_error(L, "%s", buf);
}
Exemple #19
0
void
DebugPrint(
    const char *format,
    ...
    )
{
    char output[1024];
    va_list argList;

    va_start(argList, format);
    StringCchVPrintfA(output, ARRAYSIZE(output), format, argList);
    OutputDebugStringA(output);
    va_end(argList);
}
Exemple #20
0
    LSAPI void GetResStrEx(HINSTANCE hInstance, UINT uIDText, LPSTR pszText, size_t cchText, LPCSTR pszDefText, ...)
    {
        char szFormat[MAX_LINE_LENGTH];
        va_list vargs;

        if (pszText != NULL && cchText > 0)
        {
            GetResStrA(hInstance, uIDText, szFormat, MAX_LINE_LENGTH, pszDefText);

            va_start(vargs, pszDefText);
            StringCchVPrintfA(pszText, cchText, szFormat, vargs);
            va_end(vargs);
        }
    }
Exemple #21
0
HRESULT StringCchPrintfA(
    LPSTR pszDest,
    size_t cchDest,
    LPCSTR pszFormat,
    ...) {
    va_list argList;
    HRESULT result;

    va_start(argList, pszFormat);
    result = StringCchVPrintfA(pszDest, cchDest, pszFormat, argList);
    va_end(argList);

    return result;
}
Exemple #22
0
        void AddLog(const char* lpFormat, ...)
        {
            const int nBufLen = MAX_PATH * 2;
            char szBuf[nBufLen + 1] = {0};
            va_list ap;
            va_start(ap, lpFormat);
            StringCchVPrintfA(szBuf, nBufLen, lpFormat, ap);
            va_end(ap);
            OutputDebugStringA(szBuf);

            std::wstring sTime = GetTimeHeader();
            std::string sLine = CW2A(sTime.c_str(), CP_UTF8).m_psz;
            sLine.append(szBuf);
            AddMsgToList(sLine);
        }
Exemple #23
0
    void DbgMsg( char* szMessage, ... )
    {
        char szFullMessage[MAX_PATH];
        char szFormatMessage[MAX_PATH];

        // format message
        va_list ap;
        va_start(ap, szMessage);
        (void)StringCchVPrintfA( szFormatMessage, NUMELMS(szFormatMessage), szMessage, ap );
        va_end(ap);
        (void)StringCchCatA( szFormatMessage, NUMELMS(szFormatMessage), "\n" );
        (void)StringCchCopyA( szFullMessage, NUMELMS(szFullMessage), "~*~*~*~*~*~ " );
        (void)StringCchCatA( szFullMessage, NUMELMS(szFullMessage), szFormatMessage );
        OutputDebugStringA( szFullMessage );
    }
Exemple #24
0
		static void safe_debugstr(int max_size, const char* lpformat, ...)
		{
			do 
			{
				string l_out_debug;
				l_out_debug.resize(max_size + 1);
				va_list l_va_list;
				va_start(l_va_list, lpformat);
				StringCchVPrintfA((char*)l_out_debug.c_str(), max_size + 1, lpformat, l_va_list);
				va_end(l_va_list);
				l_out_debug.resize(strlen(l_out_debug.c_str()));
	
				out_msg_base::showmsg(l_out_debug);
	
			} while (false);
		}
Exemple #25
0
VOID DXUTOutputDebugStringA(LPCSTR strMsg, ...)
{
#if defined(DEBUG) || defined(_DEBUG)
    CHAR strBuffer[512];

    va_list args;
    va_start(args, strMsg);
    StringCchVPrintfA(strBuffer, 512, strMsg, args);
    strBuffer[511] = '\0';
    va_end(args);

    OutputDebugStringA(strBuffer);
#else
    UNREFERENCED_PARAMETER(strMsg);
#endif
}
void 
hippoDebugLogU(const char *format, ...)
{
    char buf[1024];
    va_list vap;
    va_start (vap, format);
    StringCchVPrintfA(buf, sizeof(buf) / sizeof(buf[0]) - 2, format, vap);
    va_end (vap);

    StringCchCatA(buf, sizeof(buf) / sizeof(buf[0]) - 2, "\r\n");

    HippoBSTR strW;
    strW.setUTF8(buf);

    OutputDebugStringW(strW);
}
Exemple #27
0
/*++

Title:

    vsntprintf

Routine Description:

    Formats a string and returns a heap allocated string with the
    formated data.  This routine can be used to for extremely
    long format strings.  Note:  If a valid pointer is returned
    the callng functions must release the data with a call to delete.


Arguments:

    psFmt - format string
    pArgs - pointer to a argument list.

Return Value:

    Pointer to formated string.  NULL if error.

--*/
LPSTR
vsntprintf(
    IN LPCSTR      szFmt,
    IN va_list     pArgs
    )
{
    LPSTR  pszBuff;
    UINT   uSize   = 256;

    for( ; ; )
    {
        pszBuff = (LPSTR)AllocSplMem(sizeof(char) * uSize);

        if (!pszBuff)
        {
            break;
        }

        //
        // Attempt to format the string.  If format succeeds, get out
        // of the loop. If it fails, increase buffer size and continue.
        // (assuming failure is due to less buffer size).
        //
        if (SUCCEEDED ( StringCchVPrintfA(pszBuff, uSize, szFmt, pArgs) ) )
        {
            break;
        }

        FreeSplMem(pszBuff);

        pszBuff = NULL;

        //
        // Double the buffer size after each failure.
        //
        uSize *= 2;

        //
        // If the size is greater than 100k exit without formatting a string.
        //
        if (uSize > 100*1024)
        {
            break;
        }
    }
    return pszBuff;
}
int __cdecl
vfprintfEntry(
	FILE *stream,
	const char *format,
	va_list argptr 
	)
{
	PDBG_OUTPUTA Filter;
	PBTR_FILTER_RECORD Record;
	BTR_PROBE_CONTEXT Context;
	VFPRINTF Routine;
	size_t Length;
	ULONG UserLength;
	ULONG Result;
	char buffer[512];
	
	BtrFltGetContext(&Context);
	Routine = Context.Destine;
	Result = (*Routine)(stream, format, argptr);
	BtrFltSetContext(&Context);

	__try {

		StringCchVPrintfA(buffer, 512, format, argptr);
		Length = strlen(buffer) + 1;

		UserLength = FIELD_OFFSET(DBG_OUTPUTA, Text[Length]);
		Record = BtrFltAllocateRecord(UserLength, DbgUuid, _vfprintf);
		if (!Record) {
			return Result;
		}

		Filter = FILTER_RECORD_POINTER(Record, DBG_OUTPUTA);
		Filter->Length = Length;
		StringCchCopyA(Filter->Text, Length, buffer);

		BtrFltQueueRecord(Record);
	}
	__except (EXCEPTION_EXECUTE_HANDLER) {
		if (Record) {
			BtrFltFreeRecord(Record);
		}		
	}

	return Result;
}
Exemple #29
0
/********************************************************************
 WcaLogError() - called before ExitOnXXX() macro exists the function

 NOTE: writes the hresult and error string to the MSI log
********************************************************************/
extern "C" void WcaLogError(
    __in HRESULT hr,
    __in LPCSTR szMessage,
    ...
    )
{
    char szBuffer[LOG_BUFFER];
    va_list dots;

    va_start(dots, szMessage);
    StringCchVPrintfA(szBuffer, countof(szBuffer), szMessage, dots);
    va_end(dots);

    // log the message if using Wca common layer
    if (WcaIsInitialized())
        WcaLog(LOGMSG_STANDARD, "Error 0x%x: %s", hr, szBuffer);
}
Exemple #30
0
VOID
ApsWriteLogEntry(
	__in ULONG ProcessId,
	__in APS_LOG_LEVEL Level,
	__in PSTR Format,
	...
	)
{
	ULONG IsLogging;
	va_list Argument;
	PAPS_LOG_ENTRY Entry;
	CHAR Buffer[APS_LOG_TEXT_LIMIT];

	//
	// Check whether logging's enabled
	//

	IsLogging = InterlockedCompareExchange(&ApsLogObject.Flag, 0, 0);
	if (!IsLogging) {
		return;
	}

	va_start(Argument, Format);
	StringCchVPrintfA(Buffer, MAX_PATH, Format, Argument);
	va_end(Argument);

	Entry = (PAPS_LOG_ENTRY)ApsMalloc(sizeof(APS_LOG_ENTRY));
	Entry->ProcessId = ProcessId;
	Entry->Level = Level;

	GetLocalTime(&Entry->TimeStamp);
	StringCchCopyA(Entry->Text, APS_LOG_TEXT_LIMIT, Buffer);

	//
	// Queue record entry to logging queue, note that this routine can be
	// called concurrently, so logging object's lock must be acquired to
	// protect the log record queue
	//

	EnterCriticalSection(&ApsLogObject.Lock);
	InsertTailList(&ApsLogObject.ListHead, &Entry->ListEntry);
	ApsLogObject.ListDepth += 1;
	LeaveCriticalSection(&ApsLogObject.Lock);

	return;
}