NTSTATUS
MonitorCoInsertFlowContext(
_Inout_ FLOW_DATA* flowContext)
{
KLOCK_QUEUE_HANDLE lockHandle;
NTSTATUS status;
KeAcquireInStackQueuedSpinLock(&flowContextListLock, &lockHandle);
// Catch the case where we disabled monitoring after we had intended to
// associate the context to the flow so that we don't bugcheck due to
// our driver being unloaded and then receiving a call for a particular
// flow or leak the memory because we unloaded without freeing it.
if (monitoringEnabled)
{
DoTraceMessage(TRACE_FLOW_ESTABLISHED, "Creating flow for traffic.\r\n");
InsertTailList(&flowContextList, &flowContext->listEntry);
status = STATUS_SUCCESS;
}
else
{
DoTraceMessage(TRACE_FLOW_ESTABLISHED, "Unable to create flow, driver shutting down.\r\n");
// Our driver is shutting down.
status = STATUS_SHUTDOWN_IN_PROGRESS;
}
KeReleaseInStackQueuedSpinLock(&lockHandle);
return status;
}
VOID
DriverUnload(
IN PDRIVER_OBJECT driverObject
)
/*++
Routine Description:
Called to indicate that we are being unloaded and to cause an orderly
shutdown
Arguments:
driverObject Our driver
Return Value:
None
--*/
{
UNREFERENCED_PARAMETER(driverObject);
MonitorCoUninitialize();
MonitorNfUninitialize();
IoDeleteDevice(monitorDeviceObject);
IoDeleteSymbolicLink(&monitorSymbolicLink);
DoTraceMessage(TRACE_SHUTDOWN, "MsnMonitor Driver Shutting Down");
WPP_CLEANUP(driverObject);
}
// Driver unload routine
VOID
WskudpUnload(
__in PDRIVER_OBJECT DriverObject
)
{
UNREFERENCED_PARAMETER(DriverObject);
PAGED_CODE();
DoTraceMessage(TRCINFO, "UNLOAD START");
WSKCleanup();
DoTraceMessage(TRCINFO, "UNLOAD END");
WPP_CLEANUP(DriverObject);
}
//
//Routine Name:
//
// XPSRasFilter::ShutdownOperation
//
//Routine Description:
//
// Called asynchronously by the pipeline manager
// to shutdown filter operation.
//
//Arguments:
//
// None
//
//Return Value:
//
// HRESULT
// S_OK - On success
//
__checkReturn
HRESULT
XPSRasFilter::ShutdownOperation()
{
DoTraceMessage(XPSRASFILTER_TRACE_INFO, L"Shutting Down Operation");
m_pLiveness->Cancel();
return S_OK;
}
void
JobParameters::Trace() const
{
ParamValueMap::const_iterator it;
for (it = this->values.begin(); it != this->values.end(); ++it)
{
DoTraceMessage(
MSG_INFO,
"Job: %lu, %S = %S",
this->jobId, it->first.c_str(), it->second.c_str()
);
}
}
void ThrowHRException(
HRESULT hr,
char const *fileName,
int lineNum
)
{
DoTraceMessage(
XPSRASFILTER_TRACE_ERROR,
L"Throwing HRESULT Exception from %s:%d (HRESULT=%!HRESULT!)",
fileName,
lineNum,
hr
);
throw hr_error(hr);
}
//
//Routine Name:
//
// XPSRasFilter::StartOperation
//
//Routine Description:
//
// Called by the pipeline manager to start processing
// a document. Exception boundary for page processing.
//
//Arguments:
//
// None
//
//Return Value:
//
// HRESULT
// S_OK - On success
// Otherwise - Failure
//
__checkReturn
HRESULT
XPSRasFilter::StartOperation()
{
HRESULT hr = S_OK;
DoTraceMessage(XPSRASFILTER_TRACE_INFO, L"Starting Operation");
//
// Process the Xps Package
//
try {
StartOperation_throws();
}
CATCH_VARIOUS(hr);
m_pWriter->Close();
return hr;
}
NTSTATUS
MonitorCtlDriverInit(
_In_ WDFDEVICE* pDevice
)
/*++
Routine Description:
Initializes the request queue for our driver. This is how
DeviceIoControl requests are sent to KMDF drivers.
Arguments:
[in] WDFDEVICE* pDevice - Our device.
--*/
{
NTSTATUS status;
WDF_IO_QUEUE_CONFIG queueConfig;
DoTraceMessage(TRACE_INIT, "MonitorSample Control Initialization in progress.");
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
&queueConfig,
WdfIoQueueDispatchSequential
);
queueConfig.EvtIoDeviceControl = MonitorEvtDeviceControl;
status = WdfIoQueueCreate(
*pDevice,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
NULL
);
return status;
}
//
//Routine Name:
//
// PrintTicketHandler::QueryDPI
//
//Routine Description:
//
// Queries the DPI from the Print Ticket using an XPath query.
//
//Return Value:
//
// FLOAT
// DPI from the Print Ticket.
//
FLOAT
PrintTicketHandler::QueryDPI()
{
//
// Default DPI: 96 DPI
//
FLOAT dpi = 96.0;
//
// Perform the page resolution query on the print ticket
//
IXMLDOMNodeList_t pNodes;
//
// The following XPath query is fairly straightforward, except for the
// predicate attached to Feature. This is necessary to match both the
// keyword AND the namespace of the "name" of the Feature as in:
//
// <psf:Feature name="psk:PageResolution">
//
// In order to match the keyword, we match the substring after the colon:
//
// [substring-after(@name,':')='PageResolution']
//
// We also need to ensure that the namespace refers to the correct
// printschemakeywords namespace. Thus we get:
//
// [name(namespace::*[.=PRINTSCHEMAKEYWORDNS])=substring-before(@name,':')]
//
// where PRINTSCHEMAKEYWORDNS is:
//
// http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords
//
BSTR_t query(L"psf:PrintTicket/psf:Feature[substring-after(@name,':')='PageResolution']"
L"[name(namespace::*[.='http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords'])=substring-before(@name,':')]"
L"/*/*/psf:Value");
THROW_ON_FAILED_HRESULT(
m_pDOMDoc->selectNodes(query, &pNodes)
);
if (pNodes)
{
//
// The Print Ticket may have both X and Y resolutions defined, but
// the Xps Rasterization Service only accepts a single resolution.
// We query for both X and Y resolutions and take the larger of the
// two as the destination DPI. The resultant raster data could then
// be scaled down in the other dimension to achieve the non-square
// pixels.
//
LONG numResolutions;
THROW_ON_FAILED_HRESULT(
pNodes->get_length(&numResolutions)
);
if (numResolutions != 0 &&
numResolutions != 1 &&
numResolutions != 2)
{
//
// We expect 0, 1, or 2 resolutions to be set in the Print Ticket.
// Throw if this is not the case.
//
THROW_ON_FAILED_HRESULT(E_UNEXPECTED);
}
LONG maxResolution = 0;
for (INT i = 0; i < numResolutions; i++)
{
IXMLDOMNode_t pCurrentNode;
THROW_ON_FAILED_HRESULT(
pNodes->get_item(i, &pCurrentNode)
);
BSTR_t strResolution;
THROW_ON_FAILED_HRESULT(
pCurrentNode->get_text(&strResolution)
);
LONG resolution;
THROW_ON_FAILED_HRESULT(
::VarI4FromStr(
strResolution,
LOCALE_USER_DEFAULT,
0, // no custom flags
&resolution
)
);
if (resolution > maxResolution)
{
maxResolution = resolution;
}
}
dpi = static_cast<FLOAT>(maxResolution);
}
DoTraceMessage(XPSRASFILTER_TRACE_VERBOSE, L"Got DPI: %f", dpi);
return dpi;
}
//
//Routine Name:
//
// PrintTicketHandler::QueryPhysicalPageSize
//
//Routine Description:
//
// Queries the physical page size from the
// Print Ticket using an XPath query.
//
//Return Value:
//
// XPS_SIZE
// Physical page size from the Print Ticket (in XPS units).
//
XPS_SIZE
PrintTicketHandler::QueryPhysicalPageSize()
{
//
// Default page size: 8.5" x 11" at Xps DPI
//
XPS_SIZE pageSize = {11.0f * xpsDPI,
8.5f * xpsDPI};
{
//
// Perform the page width query on the print ticket
//
IXMLDOMNode_t pNode;
//
// See the comment in PrintTicketHandler::QueryDPI() for details
// about this XPath query.
//
BSTR_t query(L"psf:PrintTicket/psf:Feature[substring-after(@name,':')='PageMediaSize']"
L"[name(namespace::*[.='http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords'])=substring-before(@name,':')]"
L"/*/psf:ScoredProperty[substring-after(@name,':')='MediaSizeWidth']"
L"[name(namespace::*[.='http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords'])=substring-before(@name,':')]"
L"/psf:Value");
THROW_ON_FAILED_HRESULT(
m_pDOMDoc->selectSingleNode(query, &pNode)
);
if (pNode)
{
BSTR_t strWidth;
THROW_ON_FAILED_HRESULT(
pNode->get_text(&strWidth)
);
LONG width;
THROW_ON_FAILED_HRESULT(
::VarI4FromStr(
strWidth,
LOCALE_USER_DEFAULT,
0, // no custom flags
&width
)
);
//
// the page dimensions are in microns; convert to Xps units
//
pageSize.width = MicronsToXpsUnits(width);
}
}
{
//
// Perform the page height query on the print ticket
//
IXMLDOMNode_t pNode;
//
// See the comment in PrintTicketHandler::QueryDPI() for details
// about this XPath query.
//
BSTR_t query(L"psf:PrintTicket/psf:Feature[substring-after(@name,':')='PageMediaSize']"
L"[name(namespace::*[.='http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords'])=substring-before(@name,':')]"
L"/*/psf:ScoredProperty[substring-after(@name,':')='MediaSizeHeight']"
L"[name(namespace::*[.='http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords'])=substring-before(@name,':')]"
L"/psf:Value");
THROW_ON_FAILED_HRESULT(
m_pDOMDoc->selectSingleNode(query, &pNode)
);
if (pNode)
{
BSTR_t strHeight;
THROW_ON_FAILED_HRESULT(
pNode->get_text(&strHeight)
);
LONG height;
THROW_ON_FAILED_HRESULT(
::VarI4FromStr(
strHeight,
LOCALE_USER_DEFAULT,
0, // no custom flags
&height
)
);
//
// the page dimensions are in microns; convert to Xps unit
//
pageSize.height = MicronsToXpsUnits(height);
}
}
{
//
// Perform the landscape query on the print ticket
//
IXMLDOMNode_t pNode;
//
// See the comment in PrintTicketHandler::QueryDPI() for details
// about this XPath query.
//
BSTR_t query(L"psf:PrintTicket/psf:Feature[substring-after(@name,':')='PageOrientation']"
L"[name(namespace::*[.='http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords'])=substring-before(@name,':')]"
L"/psf:Option[substring-after(@name,':')='Landscape']"
L"[name(namespace::*[.='http://schemas.microsoft.com/windows/2003/08/printing/printschemakeywords'])=substring-before(@name,':')]");
THROW_ON_FAILED_HRESULT(
m_pDOMDoc->selectSingleNode(query, &pNode)
);
if (pNode)
{
//
// landscape. swap height and width.
//
FLOAT tmp;
tmp = pageSize.height;
pageSize.height = pageSize.width;
pageSize.width = tmp;
}
DoTraceMessage(XPSRASFILTER_TRACE_VERBOSE, L"Physical Page Size: %f x %f", pageSize.width, pageSize.height);
}
return pageSize;
}
//
//Routine Name:
//
// XPSRasFilter::StartOperation_throws
//
//Routine Description:
//
// Iterates over the 'trunk' parts of the document
// and calls appropriate processing methods.
//
//Arguments:
//
// None
//
void
XPSRasFilter::StartOperation_throws()
{
//
// CoInitialize/CoUninitialize RAII object.
// COM is inititalized for the lifetime of this method.
//
SafeCoInit coInit;
IXpsOMObjectFactory_t pOMFactory;
//
// Create Xps Object Model Object Factory instance
//
THROW_ON_FAILED_HRESULT(
::CoCreateInstance(
__uuidof(XpsOMObjectFactory),
NULL,
CLSCTX_INPROC_SERVER,
__uuidof(IXpsOMObjectFactory),
reinterpret_cast<LPVOID*>(&pOMFactory)
)
);
IOpcFactory_t pOpcFactory;
//
// Create Opc Object Factory instance
//
THROW_ON_FAILED_HRESULT(
::CoCreateInstance(
__uuidof(OpcFactory),
NULL,
CLSCTX_INPROC_SERVER,
__uuidof(IOpcFactory),
reinterpret_cast<LPVOID*>(&pOpcFactory)
)
);
//
// Create the rasterization interface
//
RasterizationInterface_t pRasInterface =
RasterizationInterface::CreateRasterizationInterface(
m_pIPropertyBag,
m_pWriter
);
//
// Create the Print Ticket Handler
//
PrintTicketHandler_t pPrintTicketHandler =
PrintTicketHandler::CreatePrintTicketHandler(
m_pIPropertyBag
);
IUnknown_t pUnk;
//
// Get first part
//
THROW_ON_FAILED_HRESULT(m_pReader->GetXpsPart(&pUnk));
while (m_pLiveness->IsAlive() &&
pUnk != NULL)
{
IXpsDocument_t pDoc;
IFixedDocumentSequence_t pFDS;
IFixedDocument_t pFD;
IFixedPage_t pFP;
if (SUCCEEDED(pUnk.QueryInterface(&pFP)))
{
DoTraceMessage(XPSRASFILTER_TRACE_VERBOSE, L"Handling a Page");
pPrintTicketHandler->ProcessPart(pFP);
ParametersFromPrintTicket printTicketParams =
pPrintTicketHandler->GetMergedPrintTicketParams();
pRasInterface->RasterizePage(
CreateXpsOMPageFromIFixedPage(pFP, pOMFactory, pOpcFactory),
printTicketParams,
m_pLiveness
);
}
else if (SUCCEEDED(pUnk.QueryInterface(&pFD)))
{
pPrintTicketHandler->ProcessPart(pFD);
}
else if (SUCCEEDED(pUnk.QueryInterface(&pFDS)))
{
pPrintTicketHandler->ProcessPart(pFDS);
}
else if (SUCCEEDED(pUnk.QueryInterface(&pDoc)))
{
//
// Do nothing with the XML Document part
//
}
else
{
//
// Any other document 'trunk' parts are ignored.
//
}
pUnk.Release();
//
// Get Next Part
//
THROW_ON_FAILED_HRESULT(m_pReader->GetXpsPart(&pUnk));
}
pRasInterface->FinishRasterization();
}
//
//Routine Name:
//
// PrintTicketHandler::GetMergedPrintTicketParams
//
//Routine Description:
//
// Queries a set of parameters from the merged print ticket.
//
// NOTE: Relies on successful calls to all three PrintTicket
// processing methods.
//
//Return Value:
//
// ParametersFromPrintTicket
// The set of parameters queried from the merged
// Print Ticket.
//
ParametersFromPrintTicket
PrintTicketHandler::GetMergedPrintTicketParams()
{
DoTraceMessage(XPSRASFILTER_TRACE_VERBOSE, L"Getting Print Ticket parameters");
if (!m_pPagePrintTicket)
{
DoTraceMessage(XPSRASFILTER_TRACE_ERROR, L"GetMergedPrintTicketParams called before ProcessPagePrintTicket");
THROW_ON_FAILED_HRESULT(E_FAIL);
}
ParametersFromPrintTicket params;
//
// Seek the Page-level Print Ticket to 0
//
LARGE_INTEGER zero;
zero.QuadPart = 0;
THROW_ON_FAILED_HRESULT(
m_pPagePrintTicket->Seek(zero, SEEK_SET, NULL)
);
//
// Load the print ticket stream into a DOM document
//
// NOTE: We are only looking for features at the Page scope for this sample,
// so we only extract features from the effective page-level PrintTicket.
//
Variant_t varStream(m_pPagePrintTicket);
VARIANT_BOOL success;
THROW_ON_FAILED_HRESULT(
m_pDOMDoc->load(varStream, &success)
);
if (!success)
{
WPP_LOG_ON_FAILED_HRESULT(E_FAIL);
THROW_ON_FAILED_HRESULT(E_FAIL);
}
//
// Set the DOM Selection namespace to simplify queries
//
BSTR_t ns(L"xmlns:psf='http://schemas.microsoft.com/windows/2003/08/printing/printschemaframework'");
Variant_t nsProp(ns);
THROW_ON_FAILED_HRESULT(
m_pDOMDoc->setProperty(L"SelectionNamespaces", nsProp)
);
//
// Query the print ticket for parameters of interest
//
params.destDPI = QueryDPI();
params.scaling = QueryScaling();
params.physicalPageSize = QueryPhysicalPageSize();
//
// We simulate imageable area by assuming a constant margin of
// around the entire page
//
params.imageableArea.x = g_pageMargin * xpsDPI;
params.imageableArea.y = g_pageMargin * xpsDPI;
params.imageableArea.height = params.physicalPageSize.height
- 2 * g_pageMargin * xpsDPI;
params.imageableArea.width = params.physicalPageSize.width
- 2 * g_pageMargin * xpsDPI;
return params;
}
NTSTATUS
TracedrvDispatchDeviceControl(
IN PDEVICE_OBJECT pDO,
IN PIRP Irp
)
/*++
Routine Description:
Dispatch routine to handle IOCTL IRPs.
Arguments:
DeviceObject - pointer to a device object.
Irp - pointer to an I/O Request Packet.
Return Value:
NT status code
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation( Irp );
ULONG ControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
ULONG i=0;
static ULONG ioctlCount = 0;
MachineState CurrentState = Offline;
PAGED_CODE();
UNREFERENCED_PARAMETER(pDO);
Irp->IoStatus.Information =
irpStack->Parameters.DeviceIoControl.OutputBufferLength;
switch ( ControlCode ) {
case IOCTL_TRACEKMP_TRACE_EVENT:
//
// Every time we get this IOCTL, we also log a trace Message if
// Trace flag one is enabled. This is used
// to illustrate that the event can be caused by user-mode.
//
ioctlCount++;
//
// Log a simple Message
//
DoTraceMessage(FLAG_ONE, "IOCTL = %d", ioctlCount);
while (i++ < MAXEVENTS) {
//
// Trace events in a loop.
//
DoTraceMessage(FLAG_ONE, "Hello, %d %s", i, "Hi" );
if ( !(i%MAXEVENTS)){
//
// Trace if level >=2 and 2 bit set by -level 2 -flags 2 in tracelog
// Uses the format string for the defined enum MachineState in the
// scanned header file
//
DoTraceLevelMessage(
TRACE_LEVEL_ERROR, // ETW Level defined in evntrace.h
FLAG_TWO, // Flag defined in WPP_CONTROL_GUIDS
"Machine State :: %!state!",
CurrentState // enum parameter
);
}
}
//
// Set a fake error status to fire the TRACE_RETURN macro below
//
status = STATUS_DEVICE_POWERED_OFF;
Irp->IoStatus.Information = 0;
break;
//
// Not one we recognize. Error.
//
default:
status = STATUS_INVALID_PARAMETER;
Irp->IoStatus.Information = 0;
break;
}
//
// Trace the return status using the TRACE_RETURN macro wich includes PRE/POST
// macros. The value could be either the fake error or invalid parameter
//
TRACE_RETURN(status);
if (status != STATUS_INVALID_PARAMETER) {
//
// Set the status back to success
//
status = STATUS_SUCCESS;
}
//
// Get rid of this request
//
Irp->IoStatus.Status = status;
IoCompleteRequest( Irp, IO_NO_INCREMENT );
return status;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT driverObject,
IN PUNICODE_STRING registryPath
)
/*++
Routine Description:
Main driver entry point. Called at driver load time
Arguments:
driverObject Our driver
registryPath A reg key where we can keep parameters
Return Value:
status of our initialization. A status != STATUS_SUCCESS aborts the
driver load and we don't get called again.
Each component is responsible for logging any error that causes the
driver load to fail.
--*/
{
NTSTATUS status;
UNICODE_STRING deviceName;
BOOLEAN validSymbolicLink = FALSE;
BOOLEAN initializedCallouts = FALSE;
//
// This macro is required to initialize software tracing on XP and beyond
// For XP and beyond use the DriverObject as the first argument.
//
WPP_INIT_TRACING(driverObject,registryPath);
DoTraceMessage(TRACE_INIT, "Initializing MsnMonitor Driver");
monitorDeviceObject = NULL;
UNREFERENCED_PARAMETER(registryPath);
driverObject->DriverUnload = DriverUnload;
status = MonitorCtlDriverInit(driverObject);
if (!NT_SUCCESS(status))
{
goto cleanup;
}
RtlInitUnicodeString(&deviceName,
MONITOR_DEVICE_NAME);
status = IoCreateDevice(driverObject, 0, &deviceName, FILE_DEVICE_NETWORK, 0, FALSE, &monitorDeviceObject);
if (!NT_SUCCESS(status))
{
goto cleanup;
}
status = MonitorCoInitialize(monitorDeviceObject);
if (!NT_SUCCESS(status))
{
initializedCallouts = TRUE;
goto cleanup;
}
RtlInitUnicodeString(&monitorSymbolicLink, MONITOR_SYMBOLIC_NAME);
status = IoCreateSymbolicLink(&monitorSymbolicLink, &deviceName);
if (!NT_SUCCESS(status))
{
goto cleanup;
}
validSymbolicLink = TRUE;
status = MonitorNfInitialize(monitorDeviceObject);
if (!NT_SUCCESS(status))
{
goto cleanup;
}
cleanup:
if (!NT_SUCCESS(status))
{
DoTraceMessage(TRACE_INIT, "MsnMonitor Initialization Failed.");
WPP_CLEANUP(driverObject);
if (initializedCallouts)
if (validSymbolicLink)
{
IoDeleteSymbolicLink(&monitorSymbolicLink);
}
if (monitorDeviceObject)
{
IoDeleteDevice(monitorDeviceObject);
}
}
return status;
}
void _printk(const char * func, const char * format, ...)
{
int ret = 0;
va_list args;
char * buf = (char *) ExAllocateFromNPagedLookasideList(&drbd_printk_msg);
if (!buf)
{
return;
}
RtlZeroMemory(buf, MAX_ELOG_BUF);
va_start(args, format);
ret = vsprintf(buf, format, args); // DRBD_DOC: improve vsnprintf
va_end(args);
int length = strlen(buf);
if (length > MAX_ELOG_BUF)
{
length = MAX_ELOG_BUF - 1;
buf[MAX_ELOG_BUF - 1] = 0;
}
else
{
// TODO: chekc min?
}
ULONG msgid = PRINTK_INFO;
int level_index = format[1] - '0';
int printLevel = 0;
CHAR szTempBuf[MAX_ELOG_BUF] = "";
BOOLEAN bSysEventLog = FALSE;
BOOLEAN bServiceLog = FALSE;
BOOLEAN bDbgLog = FALSE;
extern atomic_t g_syslog_lv_min;
extern atomic_t g_svclog_lv_min;
extern atomic_t g_dbglog_lv_min;
ASSERT((level_index >= 0) && (level_index < 8));
#ifdef _WIN32_WPP
DoTraceMessage(TRCINFO, "%s", buf);
WriteEventLogEntryData(msgids[level_index], 0, 0, 1, L"%S", buf + 3);
DbgPrintEx(FLTR_COMPONENT, DPFLTR_INFO_LEVEL, "WDRBD_INFO: [%s] %s", func, buf + 3);
ExFreeToNPagedLookasideList(&drbd_printk_msg, buf);
#else
// to write system event log.
if (level_index <= atomic_read(&g_syslog_lv_min))
bSysEventLog = TRUE;
// to send to drbd service.
if (level_index <= atomic_read(&g_svclog_lv_min))
bServiceLog = TRUE;
// to print through debugger.
if (level_index <= atomic_read(&g_dbglog_lv_min))
bDbgLog = TRUE;
// nothing to log.
if (!bSysEventLog &&
!bServiceLog &&
!bDbgLog)
{
ExFreeToNPagedLookasideList(&drbd_printk_msg, buf);
return;
}
if (bSysEventLog)
{
save_to_system_event(buf, length, level_index);
}
switch (level_index)
{
case KERN_EMERG_NUM:
case KERN_ALERT_NUM:
case KERN_CRIT_NUM:
printLevel = DPFLTR_ERROR_LEVEL;
sprintf(szTempBuf, "<%d>%s: [%s] %s", level_index, "WDRBD_FATA", func, buf + 3);
break;
case KERN_ERR_NUM:
printLevel = DPFLTR_ERROR_LEVEL;
sprintf(szTempBuf, "<%d>%s: [%s] %s", level_index, "WDRBD_ERRO", func, buf + 3);
break;
case KERN_WARNING_NUM:
printLevel = DPFLTR_WARNING_LEVEL;
sprintf(szTempBuf, "<%d>%s: [%s] %s", level_index, "WDRBD_WARN", func, buf + 3);
break;
case KERN_NOTICE_NUM:
case KERN_INFO_NUM:
printLevel = DPFLTR_INFO_LEVEL;
sprintf(szTempBuf, "<%d>%s: [%s] %s", level_index, "WDRBD_INFO", func, buf + 3);
break;
case KERN_DEBUG_NUM:
printLevel = DPFLTR_TRACE_LEVEL;
sprintf(szTempBuf, "<%d>%s: [%s] %s", level_index, "WDRBD_TRAC", func, buf + 3);
break;
default:
printLevel = DPFLTR_TRACE_LEVEL;
sprintf(szTempBuf, "<%d>%s: [%s] %s", level_index, "WDRBD_UNKN", func, buf + 3);
break;
}
strcpy_s(buf, MAX_ELOG_BUF, szTempBuf);
if (bDbgLog)
DbgPrintEx(FLTR_COMPONENT, printLevel, buf + 3);
#ifdef _WIN32_LOGLINK
if (FALSE == bServiceLog ||
FALSE == LogLink_IsUsable() ||
STATUS_SUCCESS != LogLink_QueueBuffer(buf))
{
// buf will be freed by loglink sender thread if it's queued, otherwise free it here.
ExFreeToNPagedLookasideList(&drbd_printk_msg, buf);
}
#else
// WriteEventLogEntryData(msgids[level_index], 0, 0, 1, L"%S", buf + 3); //old style
DbgPrintEx(FLTR_COMPONENT, DPFLTR_INFO_LEVEL, "WDRBD_INFO: [%s] %s", func, buf + 3);
ExFreeToNPagedLookasideList(&drbd_printk_msg, buf);
#endif
#endif
}
VOID
MonitorEvtDeviceControl (
_In_ WDFQUEUE Queue,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength,
_In_ ULONG IoControlCode
)
/*++
Handles device IO control requests. This callback drives all communication
between the usermode exe and this driver.
--*/
{
NTSTATUS status = STATUS_SUCCESS;
UNREFERENCED_PARAMETER(Queue);
UNREFERENCED_PARAMETER(OutputBufferLength);
DoTraceMessage(TRACE_DEVICE_CONTROL, "MonitorSample Dispatch Device Control: 0x%x", IoControlCode);
switch (IoControlCode)
{
case MONITOR_IOCTL_ENABLE_MONITOR:
{
WDFMEMORY pMemory;
void* pBuffer;
if (InputBufferLength < sizeof(MONITOR_SETTINGS))
{
status = STATUS_INVALID_PARAMETER;
}
else
{
status = WdfRequestRetrieveInputMemory(Request, &pMemory);
if (NT_SUCCESS(status))
{
pBuffer = WdfMemoryGetBuffer(pMemory, NULL);
status = MonitorCoEnableMonitoring((MONITOR_SETTINGS*) pBuffer);
}
}
break;
}
case MONITOR_IOCTL_DISABLE_MONITOR:
{
status = STATUS_SUCCESS;
MonitorCoDisableMonitoring();
break;
}
default:
{
status = STATUS_INVALID_PARAMETER;
}
}
WdfRequestComplete(Request, status);
}
// Driver entry routine
NTSTATUS
DriverEntry(
__in PDRIVER_OBJECT DriverObject,
__in PUNICODE_STRING RegistryPath
)
{
NTSTATUS status = STATUS_SUCCESS;
SOCKADDR_IN LocalAddress = {0,};
SOCKADDR_IN RemoteAddress = {0,};
LONG BufferSize = 0;
CHAR GreetMessage[] = "Hello there\r\n";
//PWSK_SOCKET Socket = NULL;
UNREFERENCED_PARAMETER(RegistryPath);
PAGED_CODE();
DriverObject->DriverUnload = WskudpUnload;
status = WSKStartup();
g_UdpSocket = CreateSocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, WSK_FLAG_DATAGRAM_SOCKET);
if (g_UdpSocket == NULL) {
DbgPrint("DriverEntry(): CreateSocket() returned NULL\n");
return (status = STATUS_UNSUCCESSFUL);
}
LocalAddress.sin_family = AF_INET;
LocalAddress.sin_addr.s_addr = INADDR_ANY;
//LocalAddress.sin_port = INADDR_PORT;
// Bind Required
status = Bind(g_UdpSocket, (PSOCKADDR)&LocalAddress);
if (!NT_SUCCESS(status)) {
DbgPrint("Bind() failed with status 0x%08X\n", status);
CloseSocket(g_UdpSocket);
return status;
}
RemoteAddress.sin_family = AF_INET;
RemoteAddress.sin_addr.s_addr = HTON_LONG(INADDR_LOOPBACK);//HTON_LONG(0xc0a802a2);//HTON_LONG(INADDR_LOOPBACK);
RemoteAddress.sin_port = HTON_SHORT(LOG_PORT);
if (SendTo(g_UdpSocket, GreetMessage, sizeof(GreetMessage)-1, (PSOCKADDR)&RemoteAddress) == sizeof(GreetMessage)-1) {
} else {
}
CloseSocket(g_UdpSocket);
// Initialize software tracing
WPP_INIT_TRACING(DriverObject, RegistryPath);
DoTraceMessage(TRCINFO, "LOADED");
return status;
}