|
|
/*
Copyright (c) 1992,1993 Microsoft Corporation
Module Name:
psprint.c
Abstract:
This module contains the Print Processor code for the PStoDIB facility used to translate an incoming raw PostScript Level 1 data format to DIB's which can then be rendered on an output device.
The print processor itself is defined as part of the WIN32 spool subsystem. A print processor dll is placed in a specific directory (based on the return of GetPrintProcessorDirectory(). The print processor is then added to the print subsystem by calling AddPrintProcessor() This is typically done by a setup program. The print subsystem only enumerates the print processors loaded at startup time. It does this by calling EnumPrintProcessorDataTypes() for each print processor registered with the spool subsystem. This information is kept and used to determine which PrintProcessor to use at print time based on the Datatype.
This print processor exports the 4 required functions. They are:
EnumPrintProcessorDatatypes OpenPrintProcessor PrintDocumentOnPrintProcessor ClosePrintProcessor ControlPrintProcessor
The basic flow of a job from the spooler standpoint is as follows:
At startup of system:
Print subsystem enumerates all print processors registered in the system. For each print processor the datatypes are queried via EnumPrintProcessorDatatypes. This data is then stored as part of the print spooler information.
A job is submitted via, OpenPrinter() StartDocPrinter() (Datatype = PSCRIPT1) WritePrinter() WritePrinter() ... ... EndDocPrinter() ClosePrinter()
When it comes time to print our job the spooler calls:
handle = OpenPrintProcessor(...)
PrintDocumentOnPrintProcessor( handle , ... )
ClosePrintProcessor( handle )
Optionally:
ControlPrintProcessor - For pausing jobs etc
The basic flow of our print processor is as follows:
EnumPrintProcessorDatatype
This simply returns PSCRIPT1 as a unicode string, this is the ONLY datatype we support.
OpenPrintProcessor
Here we simply allocate some memory and record the data passed in to us which is required to succesfully print the postscript job
PrintDocumentOnPrintProcessor
This is the main worker routine. At this point all the relevant data for the job is copied into some named shared memory thats given a unique name based on our thread id. This name is then passed to the PSEXE process we start via the command line. PSEXE does all the interaction with PSTODIB when it completes then PrintDocumentOnPrintProcessor returns. A process is created because the ported trueimage interpreter was not re-entrant. Thus there is no way to have multiple threads of the same process using the interpreter simultaneously without the threads writing over the interpreters global variables.
ClosePrintProcessor
This code simply cleans up any resources allocated and returns to the spooler
ControlPrintProcessor
This code controls pausing/un-pausing and aborting a job that is currently being interpreted. This is done my managing some bits stored in shared memory that is visible to the exe we started.
Author:
James Bratsanos <v-jimbr@microsoft.com or mcrafts!jamesb>
Revision History: 15 Sep 1992 Initial Version 06 Dec 1992 Modified to kick off process instead of doing all work internally 18 Mar 1993 Corrected EnumPrintProcessorDataTypes to return correctly
Notes: Tab stop: 4--*/
#include <windows.h>
#include <memory.h>
#include <stdarg.h>
#include <stdio.h>
#include <winspool.h>
#include <winsplp.h>
#include "psshmem.h"
#include "psprint.h"
#include "psutl.h"
#include <excpt.h>
#include <string.h>
#include "debug.h"
#include "..\..\lib\psdiblib.h"
/*** EnumPrintProcessorDatatypes
* * Returns back the different PrintProcessor data types which we * support. Currently ONLY PSCRIPT1. If the caller passed in a buffer * that was too small then we returned the required size. * * Return Value: * * FALSE = Success * TRUE = Failure */
BOOLEnumPrintProcessorDatatypes( IN LPTSTR pName, IN LPTSTR pPrintProcessorName, IN DWORD Level, OUT LPBYTE pDatatypes, IN DWORD cbBuf, OUT LPDWORD pcbNeeded, OUT LPDWORD pcReturned){ DATATYPES_INFO_1 *pInfo1 = (DATATYPES_INFO_1 *)pDatatypes; DWORD cbTotal=0; LPBYTE pEnd;
*pcReturned = 0;
// If the user passed in a NULL pointer there can be no lentgh
// associated so zero out
if ( pDatatypes == (LPBYTE) NULL ) { cbBuf = (DWORD) 0; }
pEnd = (LPBYTE) ( (LPBYTE)pInfo1 + cbBuf);
cbTotal += lstrlen(PSTODIB_DATATYPE) *sizeof(TCHAR) + sizeof(TCHAR) + sizeof(DATATYPES_INFO_1);
*pcbNeeded = cbTotal;
// If there is room in the buffer return the string
if (cbTotal <= cbBuf) { pEnd -=(BYTE)( lstrlen(PSTODIB_DATATYPE) *sizeof(TCHAR) + sizeof(TCHAR)); lstrcpy((LPTSTR) pEnd, PSTODIB_DATATYPE); pInfo1->pName = (LPTSTR) pEnd;
(*pcReturned)++;
} else{
SetLastError(ERROR_INSUFFICIENT_BUFFER); return FALSE; }
return( TRUE );}
/*** OpenPrintProcessor
* * Returns a HANDLE to an open print processor which is then used * to uniquely identify this print processor in future function calls * to PrintDocumentOnPrintProcessor, ClosePrintProcessor and * ControlPrintProcessor. * * Return Value: * * NULL = Failure * !NULL = Success */
HANDLEOpenPrintProcessor( IN LPTSTR pPrinterName, IN PPRINTPROCESSOROPENDATA pPrintProcessorOpenData){ PPRINTPROCESSORDATA pData; HANDLE hHeap; DWORD uDatatype=0; HANDLE hPrinter=0;
LPBYTE pEnd; LPBYTE pBuffer; HDC hDC; DWORD dwTotDevMode;
// If for some reason the spool subsystem called us with a datatype other
// than PSCRIPT1 then return back a NULL handle since we dont know
// how to handle anything other than PSCRIPT1
if (lstrcmp( PSTODIB_DATATYPE, pPrintProcessorOpenData->pDatatype) != 0 ) { SetLastError(ERROR_INVALID_DATATYPE); return( (HANDLE) NULL ); }
// Allocate some memory for our job instance data
pData = (PPRINTPROCESSORDATA) LocalAlloc( LPTR, sizeof(PRINTPROCESSORDATA));
if (pData == (PPRINTPROCESSORDATA) NULL) {
PsLogEvent(EVENT_PSTODIB_MEM_ALLOC_FAILURE, 0, NULL, PSLOG_ERROR); DBGOUT((TEXT("Memory allocation for local job storage failed"))); SetLastError( ERROR_NOT_ENOUGH_MEMORY); return((HANDLE)NULL); }
pData->cb = sizeof(PRINTPROCESSORDATA); pData->signature = PRINTPROCESSORDATA_SIGNATURE; pData->JobId = pPrintProcessorOpenData->JobId;
pData->pPrinterName = AllocStringAndCopy(pPrinterName); pData->pDatatype = AllocStringAndCopy( pPrintProcessorOpenData->pDatatype);
pData->pDocument = AllocStringAndCopy( pPrintProcessorOpenData->pDocumentName);
pData->pParameters = AllocStringAndCopy( pPrintProcessorOpenData->pParameters);
// Now copy the devmode
pData->pDevMode = NULL; if (pPrintProcessorOpenData->pDevMode != (LPDEVMODE) NULL) {
dwTotDevMode = pPrintProcessorOpenData->pDevMode->dmSize + pPrintProcessorOpenData->pDevMode->dmDriverExtra; pData->pDevMode = (LPDEVMODE) LocalAlloc( NONZEROLPTR, dwTotDevMode );
if (pData->pDevMode != NULL) { memcpy( (PVOID) pData->pDevMode, (PVOID) pPrintProcessorOpenData->pDevMode, dwTotDevMode ); pData->dwTotDevmodeSize = dwTotDevMode; } }
return( (HANDLE) pData );}
/*** GenerateSharedMemoryInfo
* * * This function copies all the relevant information into some shared * memory so we can pass the data to PSEXE. * * Entry: * pDAta: Pointer to our internal print processor data that holds all * required information for the current job we are processing * * lpPtr: Pointer to the base of our shared memory area * * Return Value: * None * */VOIDGenerateSharedMemoryInfo( IN PPRINTPROCESSORDATA pData, IN LPVOID lpPtr){ PPSPRINT_SHARED_MEMORY pShared;
pShared = lpPtr;
// Record the starting position of our dynamic data, ie where strings
// of variable length and the raw devmode bytes are stored.
//
pShared->dwNextOffset = sizeof(*pShared);
// Record the size for future reference, ie if something gets added etc
// this serves as a version number of sorts;
//
pShared->dwSize = sizeof(*pShared); pShared->dwFlags = 0;
// Move the job id over
pShared->dwJobId = pData->JobId;
UTLPSCOPYTOSHARED( pShared, pData->pPrinterName, pShared->dwPrinterName, (lstrlen(pData->pPrinterName) + 1 ) * sizeof(WCHAR) );
UTLPSCOPYTOSHARED( pShared, pData->pDocument, pShared->dwDocumentName, (lstrlen(pData->pDocument) + 1 ) * sizeof(WCHAR));
UTLPSCOPYTOSHARED( pShared, pData->pPrintDocumentDocName, pShared->dwPrintDocumentDocName, (lstrlen(pData->pPrintDocumentDocName) + 1) * sizeof(WCHAR));
UTLPSCOPYTOSHARED( pShared, pData->pDevMode, pShared->dwDevmode, pData->pDevMode->dmSize + pData->pDevMode->dmDriverExtra);
UTLPSCOPYTOSHARED( pShared, pData->pControlName, pShared->dwControlName, (lstrlen(pData->pControlName) + 1) * sizeof(WCHAR));
}
/*** PrintDocumentOnPrintProcessor
* * This function gathers all required data needed to interpret/print a * PostScript job, puts it in a shared memory area and kicks off a process * called psexe to actually interpret/print the job. When PSEXE finally * terminates this function returns. * * Starting a seperate process is done because the PSTODIB code is NOT * re-entrant and thus requires a seperate data segment (for all its globals) * for each seperate job were interpreting. Since the spooler is ONE exe * with multiple threads all threads share the same data segment and thus * dont provide the functionality we need to implement pstodib. Starting * a seperate process guarantees a new DATA segment for all globals used * in the PSTODIB component. * * * Entry: * hPrintProcessor: The handle we gave the print spooler via * OpenPrintProcessor. * * pDocumentName: The document /printer to read from so we can retrieve * the data for the current PostScript job we are to * interpret. * * Return Value: * * TRUE = Success * FALSE = Failure */
BOOLPrintDocumentOnPrintProcessor( HANDLE hPrintProcessor, LPTSTR pDocumentName){ PPRINTPROCESSORDATA pData; DOC_INFO_1 DocInfo; DWORD rc; DWORD NoRead, NoWritten; HANDLE hPrinter; DOCINFO docInfo; TCHAR szNameOfRegion[100]; TCHAR szBuff[100]; STARTUPINFO startUpInfo; PROCESS_INFORMATION processInfo; TCHAR szCmdLine[500]; WCHAR szwControlEventName[33]; DWORD dwProcessExitCode; DWORD dwProcessPriorityClass; DWORD dwThreadPriority; DWORD dwSizeOfSharedMemory = 0;
LPVOID lpBase;
if (!(pData = ValidateHandle(hPrintProcessor))) {
SetLastError(ERROR_INVALID_HANDLE); DBGOUT((TEXT("handle validation failure, PrintDocumentOnPrintProcessor"))); return FALSE; }
// Store the document name so it can get copied into shared memory
pData->pPrintDocumentDocName = AllocStringAndCopy(pDocumentName);
wsprintf( szBuff, TEXT("%s%d"), PSTODIB_STRING, GetCurrentThreadId());
lstrcpy( szwControlEventName, szBuff); lstrcat( szwControlEventName, PSTODIB_EVENT_STRING );
pData->pControlName = AllocStringAndCopy(szwControlEventName);
//
// Create an event to manage pausing/unpausing the print processor
//
pData->semPaused = CreateEvent(NULL, TRUE, TRUE,szwControlEventName);
dwSizeOfSharedMemory = sizeof(PSPRINT_SHARED_MEMORY); dwSizeOfSharedMemory += ((((pData->pPrinterName?lstrlen(pData->pPrinterName):0) + 1 ) * sizeof(WCHAR))+3) & ~0x03; dwSizeOfSharedMemory += ((((pData->pDocument?lstrlen(pData->pDocument):0) + 1 ) * sizeof(WCHAR))+3) & ~0x03; dwSizeOfSharedMemory += ((((pData->pPrintDocumentDocName?lstrlen(pData->pPrintDocumentDocName):0) + 1) * sizeof(WCHAR))+3) & ~0x03; dwSizeOfSharedMemory += (((pData->pDevMode?pData->pDevMode->dmSize:0) + (pData->pDevMode?pData->pDevMode->dmDriverExtra:0))+3) & ~0x03; dwSizeOfSharedMemory += ((((pData->pControlName?lstrlen(pData->pControlName):0) + 1) * sizeof(WCHAR))+3) & ~0x03;
// Create a shared memory area that we can write to....
pData->hShared = CreateFileMapping( INVALID_HANDLE_VALUE, // out of paging file
NULL, PAGE_READWRITE, 0, dwSizeOfSharedMemory, szBuff );
if (pData->hShared == (HANDLE) NULL) {
//
// Last error should already be set by CreateFileMapping
//
DBGOUT((TEXT("CreateFileMapping failure in psprint"))); return(FALSE);
}
lpBase = (PPSPRINT_SHARED_MEMORY) MapViewOfFile( pData->hShared, FILE_MAP_WRITE, 0, 0, dwSizeOfSharedMemory);
if (lpBase == (PPSPRINT_SHARED_MEMORY) NULL) {
//
// Last error should already be set by CreateFileMapping
//
DBGOUT((TEXT("MapViewOfFile failure in psprint"))); return(FALSE); }
// Put all required information into the shared memory area we created
GenerateSharedMemoryInfo( pData, lpBase );
// Now mark the fact that the shared memory stuff exists
pData->pShared = (PPSPRINT_SHARED_MEMORY) lpBase; pData->fsStatus |= PRINTPROCESSOR_SHMEM_DEF;
// Generate the string to pass to CreateProcess in order to start up
// PSEXE.
//
// NOTE: A interesting way to debug psexe is to simply start windbg
// first passing in psexe and the normal command line. I found
// this VERY useful during debuging.
//
//wsprintf( szCmdLine, TEXT("windbg %s %s"), PSEXE_STRING, szBuff);
wsprintf( szCmdLine, TEXT("%s %s"), PSEXE_STRING, szBuff);
// Define a STARTUPINFO structure required for CreateProcess. Since
// the new process runs DETACHED and has no console, most of the data is
// default or none.
startUpInfo.cb = sizeof(STARTUPINFO); startUpInfo.lpReserved = NULL; startUpInfo.lpDesktop = NULL; startUpInfo.lpTitle = NULL; startUpInfo.dwFlags = 0; startUpInfo.cbReserved2 = 0; startUpInfo.lpReserved2 = NULL;
// ***** IMPORTANT *****
// Create the process to actually interpret and print the specified
// PostScript job. We create this process suspended, because of the
// way the NT security system works. When CreateProcess is called we
// end up giving the security access token of the spooler process to
// PSEXE, this is incorrect since we want to give PSEXE the security
// access token of the current thread. Since the job needs to access
// resources which the spooler (running in the system context) may not
// have access to but the client (whoever submitted the job) does. To
// do this we need to set the access token of the primary thread of
// PSEXE to whatever access token the current thread has. The way
// this works is to create the process SUSPENDED then set the security
// access token of the primary thread of PSEXE, then Resume the
// thread to let it process our job. We sit blocked on WaitForSingleObject
// until the job completes.
//
//
if(!CreateProcess(NULL, szCmdLine, NULL, NULL, FALSE,#ifdef PSCHECKED
CREATE_SUSPENDED | CREATE_NEW_CONSOLE, //DEBUG
#else
CREATE_SUSPENDED | DETACHED_PROCESS,#endif
NULL, NULL, &startUpInfo, &processInfo ) ) {
//
// Last error should already be set by CreateProcess
//
PsPrintLogEventAndIncludeLastError( EVENT_PSTODIB_STARTPSEXE_FAILED, TRUE );
DBGOUT((TEXT("Create Process failed"))); return(FALSE); }
#ifdef OLD_PRIORITY
if (!SetPriorityClass(processInfo.hProcess, IDLE_PRIORITY_CLASS)){ DBGOUT((TEXT("Failed trying to reset the priority class"))); }#endif
// Just to make sure the thread priority of our new thread matches,
// the spooler and the Priority class of our exe matches the spooler
//
if( (dwProcessPriorityClass = GetPriorityClass( GetCurrentProcess())) != 0 ) {
if (!SetPriorityClass( processInfo.hProcess, dwProcessPriorityClass)) {
PsPrintLogEventAndIncludeLastError( EVENT_PSTODIB_SETPRIORITY_FAILED, FALSE ); DBGOUT((TEXT("Failed trying to reset priority class for smfpsexe"))); }
} else {
PsPrintLogEventAndIncludeLastError( EVENT_PSTODIB_SETPRIORITY_FAILED, FALSE ); DBGOUT((TEXT("Cannot retrieve current priority class!"))); }
//
// Grab the current threads priority
//
if ((dwThreadPriority = GetThreadPriority( GetCurrentThread())) != THREAD_PRIORITY_ERROR_RETURN ) { // It worked so set the thread priority
if (!SetThreadPriority( processInfo.hThread, dwThreadPriority)) {
PsPrintLogEventAndIncludeLastError( EVENT_PSTODIB_SETPRIORITY_FAILED, FALSE );
DBGOUT((TEXT("Setting thread priority failed for sfmpsexe"))); }
} else {
PsPrintLogEventAndIncludeLastError( EVENT_PSTODIB_SETPRIORITY_FAILED, FALSE ); DBGOUT((TEXT("Cannot retrieve thread priority, sfmpsprt.dll"))); }
// Why the #if 0 below....
// NT-Spooler always runs under LocalSystem. If macprint also runs as LocalSystem,
// then setting security token is a no-op. If macprint runs in some user's account then
// we run into the following problem: user32.dll fails to initialize because this new
// process running under user's context tries to access winsta0 and fails because it's got
// no privileges (only LocalSystem, not even admins get this priv). If we don't put this
// user's token, we don't lose anything except one case: if the port is configured to go to
// a unc name (e.g. \\foobar\share) where LocalSystem won't have priv, but the user will.
// But this case is a generic problem in NT-Spooler, so it's an ok compromise
//
// p.s. another solution considered: create this process with a different winsta (pass an
// empty string for lpDesktop parm above, instead of NULL). This works ok except if there
// is any dialog generated - the dialog shows up in the process's winsta, not on the desktop
// which causes the job to "hang" waiting for input! A common case of a dialog appearing is
// if the port configured is FILE.
#if 0
// Set the security access token of the primary thread of PSEXE, the
// reason for that the spooler is imporsonating the client which
// submitted the job when we get here. Since we are kicking off another
// process to do the real work for us, this new process primary thread
// must have the same privelege as the current thread (namely the client
// which submitted the job). This relies on the fact the Spooler is
// imporsonating and thus we will fail the job if the access token
// transfer fails.
//
if ( !PsUtlSetThreadToken( processInfo.hThread )) {
/*
* PsPrintLogEventAndIncludeLastError( EVENT_PSTODIB_SECURITY_PROBLEM, * TRUE ); */
DBGOUT((TEXT("Failed trying to reset the thread token")));
//
// The code that sets the abort flag used to force the job
// to abort. Since this behaviour does not mimick the spooler
// we will take it out. This always caused any pstodib jobs
// which hung around past a reboot to fail.
//
// JSB 6-25-93
//
//pData->pShared->dwFlags |= PS_SHAREDMEM_SECURITY_ABORT;
}#endif
//
// Now that we have/have not set the thread security access token for PSEXE
// let it run its course
//
ResumeThread( processInfo.hThread);
//
// Now wait for the Interpreter to complete for any reason since
// the spool subsystem does not expect us to return from
// PrintDocumentOnPrintProcessor until the job is complete
//
WaitForSingleObject( processInfo.hProcess, INFINITE);
// Get the termination reason
GetExitCodeProcess( processInfo.hProcess, &dwProcessExitCode);
// Close the handles which are not required any more
//
CloseHandle( processInfo.hProcess ); CloseHandle( processInfo.hThread );
// Clean up resources used by shared memory
//
return( (dwProcessExitCode == 0) ? TRUE : FALSE );
}
/*** PsLocalFree
* * This function simply verifies the handle is not null and calls localfree * * Entry: * lpPtr: The pointer to free if not null * * Exit: * none; **/VOID PsLocalFree( IN LPVOID lpPtr ){ if (lpPtr != (LPVOID) NULL) { LocalFree( (HLOCAL) lpPtr); }}
/*** ClosePrintProcessor
* * This functions simply cleans up any resources we used during our * job and returs: * * Entry: * hPrintProcessor: The handle we returned to the spooler in the * OpenPrintProcessor call. * * Exit: * True = Success * False = failure; **/BOOLClosePrintProcessor( IN HANDLE hPrintProcessor){ PPRINTPROCESSORDATA pData; HANDLE hHeap;
pData = ValidateHandle(hPrintProcessor);
if (!pData) { SetLastError(ERROR_INVALID_HANDLE); DBGOUT((TEXT("Invalid handle to closeprintprocessor, psprint"))); return FALSE; }
pData->fsStatus &= ~PRINTPROCESSOR_SHMEM_DEF; if (pData->pShared != (PPSPRINT_SHARED_MEMORY) NULL) { UnmapViewOfFile( (LPVOID) pData->pShared ); }
if (pData->hShared != (HANDLE) NULL) { CloseHandle( pData->hShared ); }
pData->signature = 0;
/* Release any allocated resources */
if( pData->semPaused != (HANDLE) NULL ) { CloseHandle(pData->semPaused); }
PsLocalFree( (LPVOID) pData->pPrinterName); PsLocalFree( (LPVOID) pData->pDatatype ); PsLocalFree( (LPVOID) pData->pDocument ); PsLocalFree( (LPVOID) pData->pParameters); PsLocalFree( (LPVOID) pData->pControlName);
PsLocalFree( (LPVOID) pData->pDevMode ); PsLocalFree( (LPVOID) pData->pPrintDocumentDocName ); PsLocalFree( (LPVOID) pData );
return TRUE;}
/* ControlPrintProcessor
* * This function controls pausing/unpausing of the print processor as well * aborting the current job, mainly this routine either sets/clears a named * event that the psexe program responds to, or sets a bit in some shared * memory to tell psexe to abort the current job * * Entry: * hPrintProcessor: The handle we returned to the spooler in the * OpenPrintProcessor call. * * Command: JOB_CONTROL_* (PAUSE,CANCEL,RESUME) as defined by * the Win32 print processor specification * * Exit: * TRUE: Request was satisfied * FALSE: Request was NOT satisfied **/BOOLControlPrintProcessor( IN HANDLE hPrintProcessor, IN DWORD Command){ PPRINTPROCESSORDATA pData;
if (pData = ValidateHandle(hPrintProcessor)) {
switch (Command) {
case JOB_CONTROL_PAUSE:
ResetEvent(pData->semPaused); return(TRUE); break;
case JOB_CONTROL_CANCEL:
if (pData->fsStatus & PRINTPROCESSOR_SHMEM_DEF) { // shared memory is defined so update the bit in the shared
// memory areay that signal aborting of the job
// shared memory that define our state
pData->pShared->dwFlags |= PS_SHAREDMEM_ABORTED; }
/**** Intentional fall through to release job if paused */
case JOB_CONTROL_RESUME:
SetEvent(pData->semPaused); return(TRUE); break;
default:
return(FALSE); break; }
} else { DBGOUT((TEXT("ControlPrintProcessor was passed an invalid handle, psprint"))); }
return( FALSE );}
// NOT IMPLEMENTED BY SPOOLER YET, as of 3/14/93
BOOLInstallPrintProcessor( HWND hWnd){ MessageBox(hWnd, TEXT("SfmPsPrint"), TEXT("Print Processor Setup"), MB_OK);
return TRUE;}/* ValidateHandle
* * Helper function which verifies the passed in handle is really a * handle to our own internal data structure * * Entry * * hQProc: Handle to our internal data structure * * Exit: * * NULL: Not a valid internal data structure * !NULL: A valid pointer to our internal data structure **/PPRINTPROCESSORDATAValidateHandle( HANDLE hQProc){ PPRINTPROCESSORDATA pData = (PPRINTPROCESSORDATA)hQProc;
if (pData && pData->signature == PRINTPROCESSORDATA_SIGNATURE) return( pData ); else { return( NULL ); }}
#ifdef MYPSDEBUG
/* DbgPsPrint
* * Debuger message facility which also pops up a message box * * Entry: * wprintf style format/ var arg data * * Exit: * nothing (void function) * */VOIDDbgPsPrint( PTCHAR ptchFormat, ...){ va_list marker; TCHAR buffer[512];
va_start( marker, ptchFormat ); wvsprintf( buffer, ptchFormat, marker ); va_end( marker ); OutputDebugString( buffer ); MessageBox( (HWND) NULL, (LPTSTR) &buffer, TEXT("SFMPsPrint"), MB_OK);
}#endif
/* AllocStringAndCopy
* * Helper function which allocates some memory and copies the source * string into it * * Entry: * lpSrc: Pointer to string to copy * * Exit: * NULL: Failure * !NULL: Pointer to newly allocated memory with string copied into it * */LPTSTRAllocStringAndCopy( LPTSTR lpSrc){ LPTSTR pRetString=(LPTSTR)NULL;
// Allocate the memory for the string
if (lpSrc) { pRetString = (LPTSTR) LocalAlloc(LPTR, (lstrlen(lpSrc) + 1) * sizeof(TCHAR));
if (pRetString != (LPTSTR) NULL) { lstrcpy( pRetString, lpSrc ); } else{
PsLogEvent(EVENT_PSTODIB_MEM_ALLOC_FAILURE, 0, NULL, PSLOG_ERROR); }
}
return(pRetString);
}
VOIDPsPrintLogEventAndIncludeLastError( IN DWORD dwErrorEvent, IN BOOL bError ){ TCHAR atBuff[20]; TCHAR *aStrs[2];
wsprintf( atBuff,TEXT("%d"), GetLastError());
aStrs[0] = atBuff;
PsLogEvent( dwErrorEvent, 1, aStrs, PSLOG_ERROR );
}
|
