Lenheart
/
DNF_DLL
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
DNF_DLL/test/Detours/samples/cping/cping.cpp

2246 lines
64 KiB
C++
Raw Normal View History

1211
2022-09-06 00:08:26 +08:00
//////////////////////////////////////////////////////////////////////////////
//
// Module: cping.cpp (cping.exe)
//
// Microsoft Research Detours Package
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// COM Ping text program.
//
#define _RPCRT4_
#define INITGUID
#include <winsock2.h>
#include <objbase.h>
#include <objidl.h>
#include <ocidl.h>
#include <olectl.h>
#include <shellapi.h>
#include <stdio.h>
#include <stdlib.h>
#pragma warning(push)
#if _MSC_VER > 1400
#pragma warning(disable:6102 6103) // /analyze warnings
#endif
#include <strsafe.h>
#pragma warning(pop)
#include <winnt.h>
#include <rpc.h>
#include <rpcdcep.h>
#include <detours.h>
#include "iping.h"
// ARM64 ReadTimeStampCounter is a function.
// ARM ReadTimeStampCounter is a declared function but not implemented.
// old IA64: ReadTimeStampCounter nonexisant.
// new IA64: ReadTimeStampCounter is a macro.
// old x86; ReadTimeStampCounter is a function.
// new x86: ReadTimeStampCounter is a macro.
// AMD64: ReadTimeStampCounter is a macro.
#if defined(_ARM64_) || defined(ReadTimeStampCounter)
#define GetTimeStamp() ReadTimeStampCounter()
#elif defined(_X86_) || defined(_AMD64_)
extern "C"
DWORD64
__rdtsc (
VOID
);
#pragma intrinsic(__rdtsc)
#define GetTimeStamp() __rdtsc()
#else
UINT64 GetTimeStamp(void)
{
LARGE_INTEGER a = { 0 };
QueryPerformanceCounter(&a);
return a.QuadPart;
}
#endif
#define BE_VERBOSE
////////////////////////////////////////////////////////// Assertion Handling.
//
#pragma warning(disable:4127) // Many of our asserts are constants.
#ifndef NODEBUG
#undef ASSERT
VOID PingAssertMessage(CONST PCHAR szMsg, CONST PCHAR szFile, ULONG nLine);
#define ASSERT(x) \
do { if (!((int)(x))) { PingAssertMessage(#x, __FILE__, __LINE__); DebugBreak(); }} while (0)
;
#else // NODEBUG
#undef ASSERT
#define ASSERT(x)
#endif // NODEBUG
//////////////////////////////////////////////////////////////////////////////
#define wcssize(x) ((wcslen(x) + 1) * sizeof(WCHAR))
#define strsize(x) ((strlen(x) + 1) * sizeof(CHAR))
extern "C" {
ULONG WINAPI iping_DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved);
HRESULT STDAPICALLTYPE iping_DllRegisterServer(void);
HRESULT STDAPICALLTYPE iping_DllUnregisterServer(void);
HRESULT STDAPICALLTYPE iping_DllGetClassObject(REFCLSID rclsid,
REFIID riid, PVOID *ppv);
HRESULT STDAPICALLTYPE iping_DllCanUnloadNow(void);
}
STDAPI PingMessage(PCSTR msg, ...);
///////////////////////////////////////////////////////////////////// Globals.
void * g_pBuffer = NULL;
WCHAR g_wzServerName[128];
WCHAR g_wzClientName[128];
ULONG g_cbBufferMax = 262144;
double g_dCyclesPerSecond = 0.0;
double g_dMsPerCycle = 0.0;
double g_dLatency = 0.0;
BOOL g_fSummarize = TRUE;
ULONG g_nFixedToClient = 0;
ULONG g_nFixedToServer = 0;
//////////////////////////////////////////////////////////////////////////////
//
static CHAR s_szMessageBuf[2048];
STDAPI PingMessage(PCSTR msg, ...)
{
HRESULT hr;
double d = 0.0; // Required for FP support
(void)d;
va_list args;
va_start(args, msg);
hr = StringCchVPrintfA(s_szMessageBuf, ARRAYSIZE(s_szMessageBuf), msg, args);
va_end(args);
if (FAILED(hr)) {
return hr;
}
// OutputDebugStringA(s_szMessageBuf);
printf("%s", s_szMessageBuf);
return S_FALSE;
}
VOID PingAssertMessage(CONST PCHAR szMsg, CONST PCHAR szFile, ULONG nLine)
{
PingMessage("%08lx ASSERT(%s) failed in %s, line %d.\n",
GetCurrentThreadId(), szMsg, szFile, nLine);
printf("ASSERT(%s) failed in %s, line %ld.\n", szMsg, szFile, nLine);
}
BOOLEAN CheckResult(HRESULT hr, PCSTR pszMsg, ...)
{
if (FAILED(hr)) {
HRESULT ihr;
va_list args;
va_start(args, pszMsg);
ihr = StringCchVPrintfA(s_szMessageBuf, ARRAYSIZE(s_szMessageBuf), pszMsg, args);
va_end(args);
if (FAILED(ihr)) {
return FALSE;
}
printf(" %-57.57s -> %08lx\n", s_szMessageBuf, hr);
return FALSE;
}
return TRUE;
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
#define NTSYSAPI DECLSPEC_IMPORT
#define NTAPI __stdcall
#define NTSTATUS LONG
#define PIO_APC_ROUTINE PVOID
typedef struct
{
NTSTATUS Status;
LONG Information;
} *PIO_STATUS_BLOCK;
NTSTATUS (NTAPI *Real_NtWaitForSingleObject)(HANDLE Handle,
BOOLEAN Alertable,
PLARGE_INTEGER Timeout) = NULL;
NTSTATUS (NTAPI *Real_NtDeviceIoControlFile)(HANDLE FileHandle,
HANDLE Event,
PIO_APC_ROUTINE ApcRoutine,
PVOID ApcContext,
PIO_STATUS_BLOCK IoStatusBlock,
ULONG IoControlCode,
PVOID InputBuffer,
ULONG InputBufferLength,
PVOID OutputBuffer,
ULONG OutputBufferLength) = NULL;
//////////////////////////////////////////////////////////////////////////////
//
static LONG s_nInCall = 0;
static ULONG s_nThread = 0;
enum {
E_MinValue = 0,
E_SleepEx = 1,
E_Proxy,
E_I_RpcGetBuffer,
E_I_RpcSendReceive,
E_I_RpcFreeBuffer,
E_I_RpcSend,
E_I_RpcReceive,
E_I_RpcFreePipeBuffer,
E_I_RpcReallocPipeBuffer,
E_I_RpcRequestMutex,
E_I_RpcClearMutex,
E_I_RpcAllocate,
E_I_RpcFree,
E_I_RpcPauseExecution,
E_I_RpcMonitorAssociation,
E_I_RpcStopMonitorAssociation,
E_Recv,
E_RecvFrom,
E_NtWaitForSingleObject,
E_NtDeviceIoControlFileRecv,
E_NtDeviceIoControlFile,
E_Send,
E_SendTo,
E_NtDeviceIoControlFileSend,
E_DCOM,
E_RPC,
E_UDP,
E_NET,
E_MaxValue,
E_DcomBeg = E_Proxy,
E_DcomEnd = E_Proxy,
E_RpcBeg = E_I_RpcGetBuffer,
E_RpcEnd = E_I_RpcStopMonitorAssociation,
E_UdpBeg = E_Send,
E_UdpEnd = E_NtDeviceIoControlFileSend,
E_NetBeg = E_Recv,
E_NetEnd = E_NtDeviceIoControlFile,
};
PCHAR s_rszRouteNames[E_MaxValue] =
{
"<NULL>",
"SleepEx",
"Proxy",
"I_RpcGetBuffer",
"I_RpcSendReceive",
"I_RpcFreeBuffer",
"I_RpcSend",
"I_RpcReceive",
"I_RpcFreePipeBuffer",
"I_RpcReallocPipeBuffer",
"I_RpcRequestMutex",
"I_RpcClearMutex",
"I_RpcAllocate",
"I_RpcFree",
"I_RpcPauseExecution",
"I_RpcMonitorAssociation",
"I_RpcStopMonitorAssociation",
"Recv",
"RecvFrom",
"NtWaitForSingleObject",
"NtDeviceIoControlRecv",
"NtDeviceIoControlFile",
"Send",
"SendTo",
"NtDeviceIoControlSend",
"DCOM",
"RPC",
"UDP/TCP (Send Only)",
"NET",
};
LONGLONG s_rllCycles[E_MaxValue];
LONGLONG s_rllTotals[E_MaxValue];
LONG s_rllCounts[E_MaxValue];
class CRouteTime
{
public:
inline CRouteTime(LONG nRoute)
{
if (s_nInCall && GetCurrentThreadId() == s_nThread) {
LONGLONG llBeg;
m_nOldRoute = s_nRoute;
m_llOldMinus = s_llMinus;
s_nRoute = m_nRoute = nRoute;
s_rllCounts[m_nRoute]++;
s_llMinus = 0;
ASSERT(m_nRoute != m_nOldRoute);
llBeg = GetTimeStamp();
m_llBeg = llBeg;
}
else {
m_nRoute = 0;
}
}
inline ~CRouteTime()
{
if (m_nRoute) {
LONGLONG llEnd = GetTimeStamp();
llEnd -= m_llBeg;
s_rllTotals[m_nRoute] += llEnd;
s_rllCycles[m_nRoute] += llEnd - s_llMinus;
s_nRoute = m_nOldRoute;
s_llMinus = m_llOldMinus + llEnd;
}
}
inline BOOL Routed()
{
return m_nRoute;
}
public:
ULONG m_nRoute;
ULONG m_nOldRoute;
LONGLONG m_llBeg;
LONGLONG m_llOldMinus;
static ULONG s_nRoute;
static LONGLONG s_llMinus;
};
ULONG CRouteTime::s_nRoute = 0;
LONGLONG CRouteTime::s_llMinus = 0;
VOID ZeroCycles(VOID)
{
for (ULONG n = 0; n < E_MaxValue; n++) {
s_rllCycles[n] = 0;
s_rllTotals[n] = 0;
s_rllCounts[n] = 0;
}
}
VOID DumpCycles(LONG nRoute)
{
if (s_rllCycles[nRoute] != 0 || s_rllTotals[nRoute] != 0) {
printf(";; %-21.21s %10I64d %8.3fms %10I64d %8.3fms :%6ld\n",
s_rszRouteNames[nRoute],
s_rllCycles[nRoute], (double)s_rllCycles[nRoute] * g_dMsPerCycle,
s_rllTotals[nRoute], (double)s_rllTotals[nRoute] * g_dMsPerCycle,
s_rllCounts[nRoute]);
}
}
VOID SummarizeCycles(VOID)
{
ULONG n;
for (n = E_DCOM; n <= E_NET; n++) {
s_rllCycles[n] = 0;
s_rllTotals[n] = 0;
s_rllCounts[n] = 0;
}
for (n = E_DcomBeg; n <= E_DcomEnd; n++) {
s_rllCycles[E_DCOM] += s_rllCycles[n];
s_rllTotals[E_DCOM] += s_rllTotals[n];
}
for (n = E_RpcBeg; n <= E_RpcEnd; n++) {
s_rllCycles[E_RPC] += s_rllCycles[n];
s_rllTotals[E_RPC] += s_rllTotals[n];
}
for (n = E_UdpBeg; n <= E_UdpEnd; n++) {
s_rllCycles[E_UDP] += s_rllCycles[n];
s_rllTotals[E_UDP] += s_rllTotals[n];
}
for (n = E_NetBeg; n <= E_NetEnd; n++) {
s_rllCycles[E_NET] += s_rllCycles[n];
s_rllTotals[E_NET] += s_rllTotals[n];
}
#ifdef BE_VERBOSE
printf("::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::"
"::::::::::::::::::\n");
printf(":: Protocol Cycles:\n");
DumpCycles(E_DCOM);
DumpCycles(E_RPC);
DumpCycles(E_UDP);
DumpCycles(E_NET);
#endif
s_rllCycles[E_DCOM] /= s_rllCounts[E_DCOM];
s_rllCycles[E_RPC] /= s_rllCounts[E_DCOM];
s_rllCycles[E_UDP] /= s_rllCounts[E_DCOM];
s_rllCycles[E_NET] /= s_rllCounts[E_DCOM];
s_rllTotals[E_DCOM] /= s_rllCounts[E_DCOM];
s_rllTotals[E_RPC] /= s_rllCounts[E_DCOM];
s_rllTotals[E_UDP] /= s_rllCounts[E_DCOM];
s_rllTotals[E_NET] /= s_rllCounts[E_DCOM];
#ifdef BE_VERBOSE
printf("::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::"
"::::::::::::::::::\n");
printf(":: Protocol Cycles Per DCOM Call:\n");
DumpCycles(E_DCOM);
DumpCycles(E_RPC);
DumpCycles(E_UDP);
DumpCycles(E_NET);
#endif
for (n = 0; n < E_DCOM; n++) {
s_rllCycles[n] = 0;
s_rllTotals[n] = 0;
s_rllCounts[n] = 0;
}
}
//////////////////////////////////////////////////////////////////////////////
//
DWORD (WINAPI * Real_SleepEx)(DWORD dwMilliseconds, BOOL bAlertable)
= SleepEx;
int (WSAAPI * Real_send)(SOCKET s,
const char * buf, int len, int flags)
= send;
int (WSAAPI * Real_sendto)(SOCKET s,
const char * buf, int len, int flags,
const struct sockaddr * to, int tolen)
= sendto;
int (WSAAPI * Real_recv)(SOCKET s, char * buf, int len, int flags)
= recv;
int (WSAAPI * Real_recvfrom)(SOCKET s,char * buf, int len, int flags,
struct sockaddr * from, int * fromlen)
= recvfrom;
RPC_STATUS (RPC_ENTRY *
Real_I_RpcGetBuffer)(RPC_MESSAGE * Message)
= I_RpcGetBuffer;
RPC_STATUS (RPC_ENTRY *
Real_I_RpcSendReceive)(RPC_MESSAGE * Message)
= I_RpcSendReceive;
RPC_STATUS (RPC_ENTRY *
Real_I_RpcFreeBuffer)(RPC_MESSAGE * Message)
= I_RpcFreeBuffer;
RPC_STATUS (RPC_ENTRY *
Real_I_RpcSend)(PRPC_MESSAGE Message)
= I_RpcSend;
RPC_STATUS (RPC_ENTRY *
Real_I_RpcReceive)(PRPC_MESSAGE Message,
unsigned int Size)
= I_RpcReceive;
RPC_STATUS (RPC_ENTRY *
Real_I_RpcFreePipeBuffer)(RPC_MESSAGE * Message)
= I_RpcFreePipeBuffer;
RPC_STATUS (RPC_ENTRY *
Real_I_RpcReallocPipeBuffer)(PRPC_MESSAGE Msg,
unsigned int Size)
= I_RpcReallocPipeBuffer;
void (RPC_ENTRY *
Real_I_RpcRequestMutex)(I_RPC_MUTEX * Mutex)
= I_RpcRequestMutex;
void (RPC_ENTRY *
Real_I_RpcClearMutex)(I_RPC_MUTEX Mutex)
= I_RpcClearMutex;
void * (RPC_ENTRY *
Real_I_RpcAllocate)(unsigned int Size)
= I_RpcAllocate;
void (RPC_ENTRY *
Real_I_RpcFree)(void * Object)
= I_RpcFree;
void (RPC_ENTRY *
Real_I_RpcPauseExecution)(unsigned long Milliseconds)
= I_RpcPauseExecution;
#if _MSC_VER < 1300
RPC_STATUS (RPC_ENTRY *
Real_I_RpcMonitorAssociation)(RPC_BINDING_HANDLE Handle,
PRPC_RUNDOWN RundownRoutine,
void * Context)
= I_RpcMonitorAssociation;
RPC_STATUS (RPC_ENTRY *
Real_I_RpcStopMonitorAssociation)(RPC_BINDING_HANDLE Handle)
= I_RpcStopMonitorAssociation;
#endif
//////////////////////////////////////////////////////////////////////////////
//
static DWORD WINAPI Catch_SleepEx(DWORD dwMilliseconds, BOOL bAlertable)
{
CRouteTime rt(E_SleepEx);
return Real_SleepEx(dwMilliseconds, bAlertable);
}
static int WSAAPI Catch_send(SOCKET s, const char * buf, int len, int flags)
{
CRouteTime rt(E_Send);
return Real_send(s, buf, len, flags);
}
static NTSTATUS NTAPI Catch_NtWaitForSingleObject(HANDLE Handle,
BOOLEAN Alertable,
PLARGE_INTEGER Timeout)
{
CRouteTime rt(E_NtWaitForSingleObject);
if (rt.Routed()) {
//printf("WaitForSingle(%d, %I64d)\n", Alertable, Timeout->QuadPart);
}
return Real_NtWaitForSingleObject(Handle, Alertable, Timeout);
}
#define IO_CONTROL_AFD_SEND_DATAGRAM 0x12023
#define IO_CONTROL_AFD_SEND 0x1201f
#define IO_CONTROL_AFD_RECV_DATAGRAM 0x1201b
#define IO_CONTROL_AFD_RECV 0x12017
static NTSTATUS NTAPI Catch_NtDeviceIoControlFile(HANDLE FileHandle,
HANDLE Event,
PIO_APC_ROUTINE ApcRoutine,
PVOID ApcContext,
PIO_STATUS_BLOCK IoStatusBlock,
ULONG IoControlCode,
PVOID InputBuffer,
ULONG InputBufferLength,
PVOID OutputBuffer,
ULONG OutputBufferLength)
{
if (IoControlCode == IO_CONTROL_AFD_SEND_DATAGRAM ||
IoControlCode == IO_CONTROL_AFD_SEND) {
CRouteTime rt(E_NtDeviceIoControlFileSend);
NTSTATUS NtStatus = Real_NtDeviceIoControlFile(FileHandle,
Event,
ApcRoutine,
ApcContext,
IoStatusBlock,
IoControlCode,
InputBuffer,
InputBufferLength,
OutputBuffer,
OutputBufferLength);
if (NtStatus == STATUS_PENDING) {
LARGE_INTEGER li;
li.QuadPart = INFINITE;
Real_NtWaitForSingleObject(Event, FALSE, &li);
NtStatus = IoStatusBlock->Status;
}
return NtStatus;
}
else if (IoControlCode == IO_CONTROL_AFD_RECV_DATAGRAM ||
IoControlCode == IO_CONTROL_AFD_RECV) {
CRouteTime rt(E_NtDeviceIoControlFileRecv);
return Real_NtDeviceIoControlFile(FileHandle,
Event,
ApcRoutine,
ApcContext,
IoStatusBlock,
IoControlCode,
InputBuffer,
InputBufferLength,
OutputBuffer,
OutputBufferLength);
}
else {
CRouteTime rt(E_NtDeviceIoControlFile);
if (rt.Routed()) {
printf("IoControlCode: %08lx\n", IoControlCode);
__debugbreak();
}
return Real_NtDeviceIoControlFile(FileHandle,
Event,
ApcRoutine,
ApcContext,
IoStatusBlock,
IoControlCode,
InputBuffer,
InputBufferLength,
OutputBuffer,
OutputBufferLength);
}
}
static RPC_STATUS RPC_ENTRY Catch_I_RpcGetBuffer(RPC_MESSAGE * Message)
{
CRouteTime rt(E_I_RpcGetBuffer);
return Real_I_RpcGetBuffer(Message);
}
static RPC_STATUS RPC_ENTRY Catch_I_RpcSendReceive(RPC_MESSAGE * Message)
{
CRouteTime rt(E_I_RpcSendReceive);
return Real_I_RpcSendReceive(Message);
}
static RPC_STATUS RPC_ENTRY Catch_I_RpcFreeBuffer(RPC_MESSAGE * Message)
{
CRouteTime rt(E_I_RpcFreeBuffer);
return Real_I_RpcFreeBuffer(Message);
}
static RPC_STATUS RPC_ENTRY Catch_I_RpcSend(PRPC_MESSAGE Message)
{
CRouteTime rt(E_I_RpcSend);
return Real_I_RpcSend(Message);
}
static RPC_STATUS RPC_ENTRY Catch_I_RpcReceive(PRPC_MESSAGE Message, unsigned int Size)
{
CRouteTime rt(E_I_RpcReceive);
return Real_I_RpcReceive(Message, Size);
}
static RPC_STATUS RPC_ENTRY Catch_I_RpcFreePipeBuffer(RPC_MESSAGE * Message)
{
CRouteTime rt(E_I_RpcFreePipeBuffer);
return Real_I_RpcFreePipeBuffer(Message);
}
static RPC_STATUS RPC_ENTRY Catch_I_RpcReallocPipeBuffer(PRPC_MESSAGE Message,
unsigned int NewSize)
{
CRouteTime rt(E_I_RpcReallocPipeBuffer);
return Real_I_RpcReallocPipeBuffer(Message, NewSize);
}
static void RPC_ENTRY Catch_I_RpcRequestMutex(I_RPC_MUTEX * Mutex)
{
CRouteTime rt(E_I_RpcRequestMutex);
Real_I_RpcRequestMutex(Mutex);
}
static void RPC_ENTRY Catch_I_RpcClearMutex(I_RPC_MUTEX Mutex)
{
CRouteTime rt(E_I_RpcClearMutex);
Real_I_RpcClearMutex(Mutex);
}
static void * RPC_ENTRY Catch_I_RpcAllocate(unsigned int Size)
{
CRouteTime rt(E_I_RpcAllocate);
return Real_I_RpcAllocate(Size);
}
static void RPC_ENTRY Catch_I_RpcFree(void * Object)
{
CRouteTime rt(E_I_RpcFree);
Real_I_RpcFree(Object);
}
static void RPC_ENTRY Catch_I_RpcPauseExecution(unsigned long Milliseconds)
{
CRouteTime rt(E_I_RpcPauseExecution);
Real_I_RpcPauseExecution(Milliseconds);
}
#if _MSC_VER < 1300
static RPC_STATUS RPC_ENTRY Catch_I_RpcMonitorAssociation(RPC_BINDING_HANDLE Handle,
PRPC_RUNDOWN RundownRoutine,
void * Context)
{
CRouteTime rt(E_I_RpcMonitorAssociation);
return Real_I_RpcMonitorAssociation(Handle, RundownRoutine, Context);
}
static RPC_STATUS RPC_ENTRY Catch_I_RpcStopMonitorAssociation(RPC_BINDING_HANDLE Handle)
{
CRouteTime rt(E_I_RpcStopMonitorAssociation);
return Real_I_RpcStopMonitorAssociation(Handle);
}
#endif
static STDMETHODIMP Catch_IPing_Ping(IPing *pip)
{
HRESULT hr;
InterlockedIncrement(&s_nInCall);
{
CRouteTime rt(E_Proxy);
hr = pip->Ping();
}
InterlockedDecrement(&s_nInCall);
return hr;
}
static STDMETHODIMP Catch_IPing_PingToServer(IPing *pip, LPSTR pszString)
{
HRESULT hr;
InterlockedIncrement(&s_nInCall);
{
CRouteTime rt(E_Proxy);
hr = pip->PingToServer(pszString);
}
InterlockedDecrement(&s_nInCall);
return hr;
}
static STDMETHODIMP Catch_IPing_PingToClient(IPing *pip, LPSTR *ppszString)
{
HRESULT hr;
InterlockedIncrement(&s_nInCall);
{
CRouteTime rt(E_Proxy);
hr = pip->PingToClient(ppszString);
}
InterlockedDecrement(&s_nInCall);
return hr;
}
//////////////////////////////////////////////////////////////////////////////
//
LONG RerouteEntryPoints(VOID)
{
Real_NtWaitForSingleObject
= ((NTSTATUS (NTAPI *)(HANDLE,
BOOLEAN,
PLARGE_INTEGER))
DetourFindFunction("ntdll.dll", "NtWaitForSingleObject"));
Real_NtDeviceIoControlFile
= ((NTSTATUS (NTAPI *)(HANDLE,
HANDLE,
PIO_APC_ROUTINE,
PVOID,
PIO_STATUS_BLOCK,
ULONG,
PVOID,
ULONG,
PVOID,
ULONG))
DetourFindFunction("ntdll.dll", "NtDeviceIoControlFile"));
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach(&(PVOID&)Real_NtWaitForSingleObject,
Catch_NtWaitForSingleObject);
DetourAttach(&(PVOID&)Real_NtDeviceIoControlFile,
Catch_NtDeviceIoControlFile);
DetourAttach(&(PVOID&)Real_SleepEx,
Catch_SleepEx);
DetourAttach(&(PVOID&)Real_send,
Catch_send);
DetourAttach(&(PVOID&)Real_I_RpcGetBuffer,
Catch_I_RpcGetBuffer);
DetourAttach(&(PVOID&)Real_I_RpcSendReceive,
Catch_I_RpcSendReceive);
DetourAttach(&(PVOID&)Real_I_RpcFreeBuffer,
Catch_I_RpcFreeBuffer);
DetourAttach(&(PVOID&)Real_I_RpcSend,
Catch_I_RpcSend);
DetourAttach(&(PVOID&)Real_I_RpcReceive,
Catch_I_RpcReceive);
DetourAttach(&(PVOID&)Real_I_RpcFreePipeBuffer,
Catch_I_RpcFreePipeBuffer);
DetourAttach(&(PVOID&)Real_I_RpcReallocPipeBuffer,
Catch_I_RpcReallocPipeBuffer);
DetourAttach(&(PVOID&)Real_I_RpcRequestMutex,
Catch_I_RpcRequestMutex);
DetourAttach(&(PVOID&)Real_I_RpcClearMutex,
Catch_I_RpcClearMutex);
DetourAttach(&(PVOID&)Real_I_RpcAllocate,
Catch_I_RpcAllocate);
DetourAttach(&(PVOID&)Real_I_RpcFree,
Catch_I_RpcFree);
DetourAttach(&(PVOID&)Real_I_RpcPauseExecution,
Catch_I_RpcPauseExecution);
#if _MSC_VER < 1300
DetourAttach(&(PVOID&)Real_I_RpcMonitorAssociation,
Catch_I_RpcMonitorAssociation);
DetourAttach(&(PVOID&)Real_I_RpcStopMonitorAssociation,
Catch_I_RpcStopMonitorAssociation);
#endif
return DetourTransactionCommit();
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////// Classes.
class CNetPingFactory : public IClassFactory
{
public:
CNetPingFactory();
~CNetPingFactory();
// IUnknown
STDMETHODIMP QueryInterface(REFIID riid, void** ppv);
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP_(ULONG) Release(void);
// IClassFactory
STDMETHODIMP CreateInstance(LPUNKNOWN punkOuter, REFIID iid, void **ppv);
STDMETHODIMP LockServer(BOOL fLock);
public:
static HRESULT InitSystem(VOID);
static HRESULT FiniSystem(VOID);
static HRESULT InitObject(VOID);
static HRESULT FiniObject(VOID);
static HRESULT Lock(BOOL fLock);
static HRESULT Wait(VOID);
private:
LONG m_cRef;
static HANDLE s_hevtDone;
static LONG s_nObjects;
static LONG s_nLocks;
};
class CNetPingObject : public IPing
{
public:
CNetPingObject();
~CNetPingObject();
// IUnknown
STDMETHODIMP QueryInterface(REFIID iid, void **ppv);
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP_(ULONG) Release(void);
// IPing
STDMETHODIMP Ping();
STDMETHODIMP PingToServer(LPSTR pszString);
STDMETHODIMP PingToClient(LPSTR *ppszString);
STDMETHODIMP PingToClientSize(ULONG cbOut);
private:
LONG m_cRef;
ULONG m_cbLast;
ULONG m_cbOut;
};
/////////////////////////////////////////////////////////////////////// GUIDs.
DEFINE_GUID(CLSID_NetPingObject,
0xdecdbeed, 0xd1ac, 0x11d1, 0x96, 0xbc, 0x00, 0xaa, 0x00, 0x57, 0x3f, 0xb0);
/////////////////////////////////////////////////////////// Initialize String.
//
void InitializeString(LPSTR pszString, LONG cbSize)
{
ASSERT(cbSize >= 1);
while (cbSize-- > 1) {
*pszString++ = '+';
}
*pszString = '\0';
}
BOOL GetKeyValue(HKEY hRootKey, PWCHAR pwzKey, PWCHAR pwzValueName, PWCHAR pwzValue,
DWORD cbValue)
{
HKEY hKey;
WCHAR wzKey[256];
HRESULT hr;
hr = StringCchCopyW(wzKey, ARRAYSIZE(wzKey), pwzKey);
if (FAILED(hr)) {
return FALSE;
}
if (RegOpenKeyExW(hRootKey, wzKey, 0, KEY_READ, &hKey) != NO_ERROR) {
abort:
pwzValue[0] = '\0';
return FALSE;
}
DWORD nType = 0;
cbValue -= sizeof(WCHAR);
if (RegQueryValueExW(hKey, pwzValueName, 0, &nType, (PBYTE)pwzValue, &cbValue)
!= NO_ERROR || nType != REG_SZ) {
RegCloseKey(hKey);
goto abort;
}
RegCloseKey(hKey);
cbValue /= sizeof(WCHAR);
pwzValue[cbValue] = L'\0';
return TRUE;
}
static BOOLEAN SetKeyAndValue(HKEY hRootKey,
PWCHAR pwzKey, PWCHAR pwzSubkey,
PWCHAR pwzValueName, PWCHAR pwzValue)
{
HKEY hKey;
WCHAR wzKey[256];
HRESULT hr;
hr = StringCchCopyW(wzKey, ARRAYSIZE(wzKey), pwzKey);
if (FAILED(hr)) {
return FALSE;
}
if (pwzSubkey != NULL) {
hr = StringCchCatW(wzKey, ARRAYSIZE(wzKey), L"\\");
if (FAILED(hr)) {
return FALSE;
}
hr = StringCchCatW(wzKey, ARRAYSIZE(wzKey), pwzSubkey);
if (FAILED(hr)) {
return FALSE;
}
}
if (RegCreateKeyExW(hRootKey, wzKey, 0, NULL, REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS, NULL, &hKey, NULL) != ERROR_SUCCESS) {
return FALSE;
}
if (pwzValue != NULL) {
RegSetValueExW(hKey, pwzValueName, 0, REG_SZ,
(BYTE *)pwzValue, (DWORD)wcssize(pwzValue));
}
RegCloseKey(hKey);
return TRUE;
}
static BOOLEAN SetKeyAndValue(HKEY hRootKey,
PWCHAR pwzKey, PWCHAR pwzSubkey,
PWCHAR pwzValueName,
PBYTE pbData, ULONG cbData)
{
HKEY hKey;
WCHAR wzKey[256];
HRESULT hr;
hr = StringCchCopyW(wzKey, ARRAYSIZE(wzKey), pwzKey);
if (FAILED(hr)) {
return FALSE;
}
if (pwzSubkey != NULL) {
hr = StringCchCatW(wzKey, ARRAYSIZE(wzKey), L"\\");
if (FAILED(hr)) {
return FALSE;
}
hr = StringCchCatW(wzKey, ARRAYSIZE(wzKey), pwzSubkey);
if (FAILED(hr)) {
return FALSE;
}
}
if (RegCreateKeyExW(hRootKey, wzKey, 0, NULL, REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS, NULL, &hKey, NULL) != ERROR_SUCCESS) {
return FALSE;
}
if (pbData != NULL) {
RegSetValueExW(hKey, pwzValueName, 0, REG_BINARY, pbData, cbData);
}
RegCloseKey(hKey);
return TRUE;
}
static void Register(void)
{
WCHAR wzModule[256];
WCHAR wzName[256];
WCHAR wzValue[256];
WCHAR wzClass[48];
WCHAR wzKey[256];
PWCHAR pwz;
HRESULT hr;
BYTE rgEveryone[] = {
0x01,0x00,0x04,0x80,0x34,0x00,0x00,0x00,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x14,0x00,0x00,0x00,0x02,0x00,0x20,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x18,0x00,
0x01,0x00,0x00,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x01,0x05,0x00,0x00,0x00,0x00,0x00,0x05,0x15,0x00,0x00,0x00,
0xa0,0x65,0xcf,0x7e,0x78,0x4b,0x9b,0x5f,0xe7,0x7c,0x87,0x70,0x32,0x7f,0x00,0x00,
0x01,0x05,0x00,0x00,0x00,0x00,0x00,0x05,0x15,0x00,0x00,0x00,0xa0,0x65,0xcf,0x7e,
0x78,0x4b,0x9b,0x5f,0xe7,0x7c,0x87,0x70,0x32,0x7f,0x00,0x00
};
GetModuleFileNameW(NULL, wzModule, sizeof(wzModule)/sizeof(WCHAR));
if ((pwz = wcsrchr(wzModule, '\\')) != NULL) {
hr = StringCchCopyW(wzName, ARRAYSIZE(wzName), pwz + 1);
}
else if ((pwz = wcsrchr(wzModule, ':')) != NULL) {
hr = StringCchCopyW(wzName, ARRAYSIZE(wzName), pwz + 1);
}
else {
hr = StringCchCopyW(wzName, ARRAYSIZE(wzName), wzModule);
}
CheckResult(hr, "IPing_DllRegisterServer");
// printf("Server: %ls / %ls\n", wzModule, wzName);
StringFromGUID2(CLSID_NetPingObject, wzClass, ARRAYSIZE(wzClass));
// printf(" Class: %ls\n", wzClass);
hr = StringCchCopyW(wzKey, ARRAYSIZE(wzKey), L"CLSID\\");
CheckResult(hr, "IPing_DllRegisterServer");
hr = StringCchCatW(wzKey, ARRAYSIZE(wzKey), wzClass);
CheckResult(hr, "IPing_DllRegisterServer");
SetKeyAndValue(HKEY_CLASSES_ROOT, wzKey, NULL, NULL, L"COM Ping Network Server");
hr = StringCchPrintfW(wzValue, ARRAYSIZE(wzValue), L"%ls /s", wzModule);
CheckResult(hr, "IPing_DllRegisterServer");
SetKeyAndValue(HKEY_CLASSES_ROOT, wzKey, L"LocalServer32", NULL, wzValue);
SetKeyAndValue(HKEY_CLASSES_ROOT, wzKey, L"LaunchPermission", NULL, L"Y");
SetKeyAndValue(HKEY_CLASSES_ROOT, wzKey, NULL, L"AppID", wzClass);
hr = StringCchCopyW(wzKey, ARRAYSIZE(wzKey), L"AppID\\");
CheckResult(hr, "IPing_DllRegisterServer");
hr = StringCchCatW(wzKey, ARRAYSIZE(wzKey), wzClass);
CheckResult(hr, "IPing_DllRegisterServer");
SetKeyAndValue(HKEY_CLASSES_ROOT, wzKey, NULL, NULL, L"COM Ping Network Server");
SetKeyAndValue(HKEY_CLASSES_ROOT, wzKey, NULL, L"RunAs", L"Interactive User");
SetKeyAndValue(HKEY_CLASSES_ROOT, wzKey, NULL, L"AccessPermission",
rgEveryone, sizeof(rgEveryone));
hr = StringCchCopyW(wzKey, ARRAYSIZE(wzKey), L"AppID\\");
CheckResult(hr, "IPing_DllRegisterServer");
hr = StringCchCatW(wzKey, ARRAYSIZE(wzKey), wzName);
CheckResult(hr, "IPing_DllRegisterServer");
SetKeyAndValue(HKEY_CLASSES_ROOT, wzKey, NULL, L"AppID", wzClass);
/////////////////////////////////////////////////// Register Proxy & Stub.
//
iping_DllRegisterServer();
CheckResult(hr, "IPing_DllRegisterServer");
//////////////////////////////////////////////// Register Processor Speed.
//
DWORD cycles = 0;
hr = StringCchCopyW(wzKey, ARRAYSIZE(wzKey), L"Software\\Microsoft\\Detours\\ProcessorCycles");
CheckResult(hr, "IPing_DllRegisterServer");
if (GetKeyValue(HKEY_LOCAL_MACHINE, wzKey, NULL, wzValue, sizeof(wzValue))) {
cycles = _wtoi(wzValue);
printf("[Recorded Cycles/Second: %ld]\n", cycles);
}
if (cycles < 10000) {
LONGLONG llBeg;
LONGLONG llEnd;
printf("[Calibrating Processors...]\r");
LARGE_INTEGER liBeg;
LARGE_INTEGER liEnd;
LARGE_INTEGER liBrk;
LARGE_INTEGER liFrq;
QueryPerformanceFrequency(&liFrq);
QueryPerformanceCounter(&liBeg);
llBeg = GetTimeStamp();
liBrk.QuadPart = liBeg.QuadPart + liFrq.QuadPart * 5;
do {
QueryPerformanceCounter(&liEnd);
llEnd = GetTimeStamp();
} while (liEnd.QuadPart < liBrk.QuadPart);
double secs = (double)(liEnd.QuadPart - liBeg.QuadPart) / (double)liFrq.QuadPart;
double clks = (double)(llEnd - llBeg);
double cycs = clks / secs;
cycles = (DWORD)cycs;
printf("[Measured Cycles/Second: %ld] \n", cycles);
hr = StringCchPrintfW(wzValue, ARRAYSIZE(wzValue), L"%d", cycles);
CheckResult(hr, "IPing_DllRegisterServer");
SetKeyAndValue(HKEY_LOCAL_MACHINE, wzKey, NULL, NULL, wzValue);
}
}
void Unregister(void)
{
///////////////////////////////////////////////// Unregister Proxy & Stub.
//
HRESULT hr = iping_DllUnregisterServer();
if (FAILED(hr)) {
CheckResult(hr, "IPing_DllUnregisterServer");
}
}
//////////////////////////////////////////////////////////////////////////////
//
HRESULT GetClockInfo(LONGLONG *pllCyclesPerSecond)
{
WCHAR wzKey[512];
WCHAR wzValue[128];
LONG cbValue;
HRESULT hr;
////////////////////////////////////////////////////////// Check Registry.
cbValue = sizeof(wzValue);
hr = StringCchCopyW(wzKey, ARRAYSIZE(wzKey), L"Software\\Microsoft\\Detours\\ProcessorCycles");
CheckResult(hr, "GetClockInfo");
if (RegQueryValueW(HKEY_LOCAL_MACHINE, wzKey, wzValue, &cbValue) == NO_ERROR) {
*pllCyclesPerSecond = _wtoi(wzValue);
return S_OK;
}
*pllCyclesPerSecond = 1000000;
return E_FAIL;
}
///////////////////////////////////////////////////////// CNetPingFactory.
//
LONG CNetPingFactory::s_nObjects = 0;
LONG CNetPingFactory::s_nLocks = 0;
HANDLE CNetPingFactory::s_hevtDone = NULL;
CNetPingFactory::CNetPingFactory()
{
m_cRef = 1;
}
CNetPingFactory::~CNetPingFactory()
{
m_cRef = 0;
}
ULONG CNetPingFactory::AddRef(void)
{
return InterlockedIncrement(&m_cRef);
}
ULONG CNetPingFactory::Release(void)
{
if (InterlockedDecrement(&m_cRef) == 0) {
delete this;
return 0;
}
return 1;
}
HRESULT CNetPingFactory::InitSystem(VOID)
{
s_nObjects = 0;
s_nLocks = 0;
s_hevtDone = CreateEvent(NULL, FALSE, FALSE, NULL);
if (s_hevtDone == NULL) {
HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
CheckResult(hr, "Server: CreateEvent");
exit(hr);
}
return S_OK;
}
HRESULT CNetPingFactory::FiniSystem(VOID)
{
if (s_hevtDone != NULL) {
CloseHandle(s_hevtDone);
s_hevtDone = NULL;
}
return S_OK;
}
HRESULT CNetPingFactory::InitObject(VOID)
{
InterlockedIncrement(&s_nObjects);
return S_OK;
}
HRESULT CNetPingFactory::FiniObject(VOID)
{
if (InterlockedDecrement(&s_nObjects) == 0 && s_nLocks == 0)
SetEvent(s_hevtDone);
return S_OK;
}
HRESULT CNetPingFactory::Lock(BOOL fLock)
{
if (fLock) {
InterlockedIncrement(&s_nLocks);
}
else {
if (InterlockedDecrement(&s_nLocks) == 0 && s_nObjects == 0)
SetEvent(s_hevtDone);
}
return S_OK;
}
HRESULT CNetPingFactory::Wait(VOID)
{
DWORD dwWaitResult;
MSG msg;
for (;;) {
dwWaitResult = MsgWaitForMultipleObjects(1, &s_hevtDone,
FALSE, INFINITE,
QS_ALLINPUT);
if (dwWaitResult == WAIT_OBJECT_0) {
ResetEvent(s_hevtDone);
break;
}
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return S_OK;
}
STDMETHODIMP CNetPingFactory::QueryInterface(REFIID riid, void** ppv)
{
if (ppv == NULL) {
return E_INVALIDARG;
}
if (riid == IID_IClassFactory || riid == IID_IUnknown) {
*ppv = (IClassFactory *) this;
AddRef();
return S_OK;
}
*ppv = NULL;
return E_NOINTERFACE;
}
HRESULT CNetPingFactory::LockServer (BOOL fLock)
{
return Lock(fLock);
}
STDMETHODIMP CNetPingFactory::CreateInstance(LPUNKNOWN punkOuter,
REFIID riid, void** ppv)
{
LPUNKNOWN punk;
HRESULT hr;
*ppv = NULL;
if (punkOuter != NULL) {
return CLASS_E_NOAGGREGATION;
}
printf(" Server: IClassFactory:CreateInstance\n");
punk = new CNetPingObject;
if (punk == NULL) {
return E_OUTOFMEMORY;
}
hr = punk->QueryInterface(riid, ppv);
punk->Release();
return hr;
}
/////////////////////////////////////////////////////////////// CNetPingObject.
//
CNetPingObject::CNetPingObject()
{
m_cRef = 1;
m_cbLast = ~0u;
m_cbOut = 2;
CNetPingFactory::InitObject();
}
CNetPingObject::~CNetPingObject()
{
CNetPingFactory::FiniObject();
}
STDMETHODIMP CNetPingObject::QueryInterface(REFIID riid, void** ppv)
{
if (ppv == NULL) {
return E_INVALIDARG;
}
if (riid == IID_IUnknown || riid == IID_IPing) {
*ppv = (IPing *) this;
AddRef();
return S_OK;
}
*ppv = NULL;
return E_NOINTERFACE;
}
STDMETHODIMP_(ULONG) CNetPingObject::AddRef(void)
{
return InterlockedIncrement(&m_cRef);
}
STDMETHODIMP_(ULONG) CNetPingObject::Release(void)
{
if (InterlockedDecrement(&m_cRef) == 0) {
delete this;
return 0;
}
return 1;
}
STDMETHODIMP CNetPingObject::Ping()
{
return S_OK;
}
STDMETHODIMP CNetPingObject::PingToServer(LPSTR pszString)
{
(void)pszString;
return S_OK;
}
STDMETHODIMP CNetPingObject::PingToClient(LPSTR *ppszString)
{
LPSTR pszString = (LPSTR)CoTaskMemAlloc(m_cbOut);
if (pszString == NULL) {
return E_OUTOFMEMORY;
}
CopyMemory(pszString, g_pBuffer, m_cbOut);
*ppszString = pszString;
return S_OK;
}
STDMETHODIMP CNetPingObject::PingToClientSize(ULONG cbOut)
{
if (cbOut < 1) {
return E_INVALIDARG;
}
InitializeString((LPSTR)g_pBuffer, cbOut);
m_cbOut = cbOut;
return S_OK;
}
//////////////////////////////////////////////////////////////////////////////
//
class CSampleRecord
{
public:
DOUBLE m_dTime;
FILETIME m_nWhen;
LONG m_cbToClient;
LONG m_cbToServer;
DOUBLE m_dDcom;
DOUBLE m_dRpc;
DOUBLE m_dUdp;
DOUBLE m_dNet;
protected:
static LONG s_cbToClient;
static LONG s_cbToServer;
public:
CSampleRecord();
CSampleRecord(IPing *pIPing, LONG cbToClient, LONG cbToServer);
HRESULT Measure(IPing *pIPing, LONG cbToClient, LONG cbToServer);
HRESULT Write();
double GetTime() { return m_dTime; }
FILETIME GetWhen() { return m_nWhen; }
LONG GetToClient() { return m_cbToClient; }
LONG GetToServer() { return m_cbToServer; }
};
//////////////////////////////////////////////////////////////////////////////
//
LONG CSampleRecord::s_cbToClient = 0;
LONG CSampleRecord::s_cbToServer = 0;
//////////////////////////////////////////////////////////////////////////////
//
CSampleRecord::CSampleRecord()
{
m_dTime = 0;
m_dDcom = 0;
m_dRpc = 0;
m_dUdp = 0;
m_dNet = 0;
}
CSampleRecord::CSampleRecord(IPing *pIPing, LONG cbToClient, LONG cbToServer)
{
Measure(pIPing, cbToClient, cbToServer);
}
HRESULT CSampleRecord::Measure(IPing *pIPing, LONG cbToClient, LONG cbToServer)
{
HRESULT hr;
LONGLONG llBeg;
LONGLONG llEnd;
GetSystemTimeAsFileTime(&m_nWhen);
m_cbToClient = cbToClient;
m_cbToServer = cbToServer;
if (cbToClient == 0 && cbToServer == 0) {
llBeg = GetTimeStamp();
hr = Catch_IPing_Ping(pIPing);
llEnd = GetTimeStamp();
}
else if (cbToClient) {
if (s_cbToClient != cbToClient) {
hr = pIPing->PingToClientSize(cbToClient);
s_cbToClient = cbToClient;
}
LPSTR pszString = NULL;
llBeg = GetTimeStamp();
hr = Catch_IPing_PingToClient(pIPing, &pszString);
llEnd = GetTimeStamp();
if (pszString) {
LONG cb = (LONG)strlen(pszString) + 1;
ASSERT(cb == cbToClient);
CoTaskMemFree(pszString);
pszString = NULL;
}
}
else {
if (s_cbToServer != cbToServer) {
InitializeString((LPSTR)g_pBuffer, cbToServer);
s_cbToServer = cbToServer;
}
llBeg = GetTimeStamp();
hr = Catch_IPing_PingToServer(pIPing, (LPSTR)g_pBuffer);
llEnd = GetTimeStamp();
}
if (FAILED(hr)) {
printf(";; Operation failed: %08lx\n", hr);
exit(999);
}
if (g_fSummarize) {
SummarizeCycles();
m_dDcom = (double)s_rllCycles[E_DCOM] * g_dMsPerCycle;
m_dRpc = (double)s_rllCycles[E_RPC] * g_dMsPerCycle;
m_dUdp = (double)s_rllCycles[E_UDP] * g_dMsPerCycle;
m_dNet = (double)s_rllCycles[E_NET] * g_dMsPerCycle;
}
m_dTime = (double)(llEnd - llBeg) * g_dMsPerCycle;
return S_OK;
}
HRESULT CSampleRecord::Write()
{
SYSTEMTIME st;
FILETIME ft;
FileTimeToLocalFileTime(&m_nWhen, &ft);
FileTimeToSystemTime(&ft, &st);
printf("%02d/%02d %2d:%02d:%02d %6ld %ld %6.3f [ %6.3f %6.3f %6.3f %6.3f ]\n",
st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond,
m_cbToClient, m_cbToServer, m_dTime,
m_dDcom, m_dRpc, m_dUdp, m_dNet);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////////
//
double NetTest(HKEY hNetwork, IPing *pIPing,
BOOLEAN fToClient, LONG cbPacket, LONG nCount)
{
//////////////////////////////////////////////////////////////////// ToClient.
//
HRESULT hr;
double msAvg = 0.0;
double msMin = 1.0e12;
double msMax = 0.0;
ULONG nMax = 999;
ULONG nMin = 999;
if (fToClient) {
printf(">Client %6ld %6ld ", cbPacket, nCount);
}
else {
printf(">Server %6ld %6ld ", cbPacket, nCount);
}
for (LONG n = 0; n < nCount; n++) {
double ms;
if (fToClient) {
ms = CSampleRecord(pIPing, cbPacket, 0).GetTime();
}
else {
ms = CSampleRecord(pIPing, 0, cbPacket).GetTime();
}
if (ms < 0) {
break;
}
if (msMin > ms) {
msMin = ms;
nMin = n;
}
if (msMax < ms) {
msMax = ms;
nMax = n;
}
msAvg += ms;
}
if (nCount) {
msAvg /= nCount;
}
if (cbPacket == 0) {
g_dLatency = msMin;
}
double mbps = (double)cbPacket / msMin;
mbps *= 8.0 * 1000.0 / 1024.0 / 1024.0;
double mbps2 = (double)cbPacket / (msMin - g_dLatency);
mbps2 *= 8.0 * 1000.0 / 1024.0 / 1024.0;
if (cbPacket == 0) {
mbps2 = 0;
}
if (hNetwork != NULL) {
WCHAR wzKey[64];
WCHAR wzLatency[64];
if (fToClient) {
hr = StringCchPrintfW(wzKey, ARRAYSIZE(wzKey), L"ToClient\\%d", cbPacket);
CheckResult(hr, "NetTest");
}
else {
hr = StringCchPrintfW(wzKey, ARRAYSIZE(wzKey), L"ToServer\\%d", cbPacket);
CheckResult(hr, "NetTest");
}
hr = StringCchPrintfW(wzLatency, ARRAYSIZE(wzLatency), L"%I64d", msAvg);
CheckResult(hr, "NetTest");
RegSetValueW(hNetwork, wzKey, REG_SZ, wzLatency, (DWORD)wcssize(wzLatency));
}
printf("%8.3f %8.3f %8.3f %9.4f %8.3f %9.4f%3ld\n",
msMin,
msAvg,
msMax,
mbps,
msMin - g_dLatency,
mbps2,
nMax);
return mbps;
}
//////////////////////////////////////////////////////////////////////// main.
static WCHAR wzServers[32][64];
static int nServers = 0;
void Sample_Fixed(IPing *pIPing)
{
CSampleRecord csrRecords[512];
LONG nRecords = 0;
HRESULT hr;
double dAvg = 0;
double dMin = 500000.0;
double dMax = 0.0;
double dMinDcom = dMin;
double dMinRpc = dMin;
double dMinUdp = dMin;
double dMinNet = dMin;
for (int i = 0; i < 512; i++) {
CSampleRecord& csr = csrRecords[nRecords++];
hr = csr.Measure(pIPing, g_nFixedToClient, g_nFixedToServer);
double d = csr.GetTime();
if (dMin > d) {
dMin = d;
}
if (dMax < d) {
dMax = d;
}
if (dMinDcom > csr.m_dDcom) {
dMinDcom = csr.m_dDcom;
}
if (dMinRpc > csr.m_dRpc) {
dMinRpc = csr.m_dRpc;
}
if (dMinUdp > csr.m_dUdp) {
dMinUdp = csr.m_dUdp;
}
if (dMinNet > csr.m_dNet) {
dMinNet = csr.m_dNet;
}
dAvg += d;
}
dAvg /= 512;
printf("size: %ld, min: %.3f, max: %.3f avg: %.3f [ %8.3f %8.3f %8.3f %8.3f ]\n",
g_nFixedToClient, dMin, dMax, dAvg, dMinDcom, dMinRpc, dMinUdp, dMinNet);
for (int n = 0; n < nRecords; n++) {
csrRecords[n].Write();
}
}
void Sample_Simple(IPing *pIPing)
{
CSampleRecord csrRecords[512];
LONG nRecords = 0;
HRESULT hr;
for (int cb = 0; cb < 64000; cb = cb ? cb << 1 : 32) {
double n[5];
int i = 0;
for (; i < 5; i++) {
CSampleRecord& csr = csrRecords[nRecords++];
hr = csr.Measure(pIPing, cb, 0);
n[i] = csr.GetTime();
}
double nAvg = 0;
double nApx = 0;
double nMin = n[0];
double nMax = n[0];
for (i = 0; i < 5; i++) {
if (nMin > n[i]) {
nMin = n[i];
}
if (nMax < n[i]) {
nMax = n[i];
}
nAvg += n[i];
}
nApx = nAvg - nMax;
nAvg /= 5;
nApx /= 4;
printf("min: %8.3f ms (%6d) %7.3f%7.3f%7.3f%7.3f%7.3f:%8.3f%8.3f\n",
nMin, cb, n[0], n[1], n[2], n[3], n[4], nAvg, nApx);
}
for (int n = 0; n < nRecords; n++) {
csrRecords[n].Write();
}
}
void Sample_More(IPing *pIPing)
{
CSampleRecord csrRecords[64];
LONG nRecords = 0;
for (int cb = 0; cb < 64000; cb = cb ? cb << 1 : 32) {
int i = 0;
for (; i < 64; i++) {
CSampleRecord& csr = csrRecords[nRecords++];
csr.Measure(pIPing, cb, 0);
}
double nAvg = 0;
double nMin = csrRecords[0].GetTime();
double nMax = csrRecords[0].GetTime();
for (i = 0; i < 64; i++) {
double n = csrRecords[i].GetTime();
if (nMin > n) {
nMin = n;
}
if (nMax < n) {
nMax = n;
}
nAvg += n;
}
nAvg /= i;
printf("min: %8.3f ms (%6d) : %8.3f %8.3f\n",
nMin, cb, nMax, nAvg);
for (int n = 0; n < nRecords; n++) {
csrRecords[n].Write();
}
nRecords = 0;
}
}
void Sample_Less(IPing *pIPing)
{
CSampleRecord csrRecords[16];
LONG nRecords = 0;
for (int cb = 0; cb < 64000; cb = cb ? cb << 1 : 16) {
int i = 0;
for (; i < 16; i++) {
CSampleRecord& csr = csrRecords[nRecords++];
csr.Measure(pIPing, cb, 0);
}
double nAvg = 0;
double nMin = csrRecords[0].GetTime();
double nMax = csrRecords[0].GetTime();
for (i = 0; i < 16; i++) {
double n = csrRecords[i].GetTime();
if (nMin > n) {
nMin = n;
}
if (nMax < n) {
nMax = n;
}
nAvg += n;
}
nAvg /= i;
printf("min: %8.3f ms (%6d) : %8.3f %8.3f\n",
nMin, cb, nMax, nAvg);
for (int n = 0; n < nRecords; n++) {
csrRecords[n].Write();
}
nRecords = 0;
}
}
void Sample_Profile(IPing *pIPing)
{
CSampleRecord csrRecords[64];
double dbZero = 0;
printf("\nPacket_Size_ Min_Latency Max_Latency Avg_Latency "
"Relative_Bnd ___Bandwidth\n");
for (int cb = 0; cb < 256 * 1024;) {
int n = 0;
for (; n < 64; n++) {
CSampleRecord& csr = csrRecords[n];
csr.Measure(pIPing, cb, 0);
}
double dbAvg = 0;
double dbMin = csrRecords[0].GetTime();
double dbMax = csrRecords[0].GetTime();
LONG nMin = 0;
LONG nMax = 0;
for (n = 0; n < 64; n++) {
double db = csrRecords[n].GetTime();
if (dbMin > db) {
dbMin = db;
nMin = n;
}
if (dbMax < db) {
dbMax = db;
nMax = n;
}
dbAvg += db;
}
dbAvg /= n;
if (cb == 0) {
dbZero = dbMin;
}
double dbBnd = 0;
if (dbMin > dbZero) {
dbBnd = ((8 * cb) * 1000.0) / (1024 * 1024);
dbBnd /= dbMin - dbZero;
}
double dbReal = ((8 * cb) * 1000.0) / (1024 * 1024) / dbMin;
printf("%6d bytes %9.3fms %9.3fms %9.3fms %8.3fMbps %8.3fMbps\r",
cb, dbMin, dbMax, dbAvg, dbBnd, dbReal);
csrRecords[nMin].Write();
if (cb < 2048) {
cb++;
}
else if (cb < 4096) {
cb += 2;
}
else if (cb < 8192) {
cb += 8;
}
else if (cb < 16384) {
cb += 32;
}
else {
cb += 128;
}
}
}
//////////////////////////////////////////////////////////////////////////////
//
class CInit
{
public:
CInit(HINSTANCE hinst)
{
m_hinst = hinst;
AllocConsole();
// initialize COM for free-threading
HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
if (FAILED(hr)) {
CheckResult(hr, "CoInitializeEx");
exit(hr);
}
ULONG ul = iping_DllMain(m_hinst, DLL_PROCESS_ATTACH, NULL);
ASSERT(ul);
}
~CInit()
{
ULONG ul = iping_DllMain(m_hinst, DLL_PROCESS_DETACH, NULL);
ASSERT(ul);
CoUninitialize();
}
private:
HINSTANCE m_hinst;
};
class CInitStub
{
public:
CInitStub()
{
m_dwRegister = ~0u;
IClassFactory *pClassFactory = NULL;
HRESULT hr = iping_DllGetClassObject(IID_IPing,
IID_IUnknown,
(void **)&pClassFactory);
if (FAILED(hr)) {
CheckResult(hr, "IPing_DllGetClassObject");
ASSERT(SUCCEEDED(hr));
}
if (pClassFactory) {
hr = CoRegisterClassObject(IID_IPing,
pClassFactory,
CLSCTX_SERVER,
REGCLS_MULTIPLEUSE,
&m_dwRegister);
if (FAILED(hr)) {
ASSERT(SUCCEEDED(hr));
CheckResult(hr, "CoRegisterClassObject(IID_IPing)\n");
}
pClassFactory->Release();
pClassFactory = NULL;
}
}
~CInitStub()
{
if (m_dwRegister != ~0u) {
CoRevokeClassObject(m_dwRegister);
m_dwRegister = ~0u;
}
}
private:
DWORD m_dwRegister;
};
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
int __cdecl main(void)
{
CInit cinit(GetModuleHandle(NULL));
int argc;
WCHAR **argv = CommandLineToArgvW(GetCommandLineW(), &argc);
HRESULT hr;
BOOLEAN fUnreg = FALSE;
BOOLEAN fNeedHelp = FALSE;
BOOLEAN fServer = FALSE;
BOOLEAN fLong = FALSE;
BOOLEAN fProfile = FALSE;
BOOLEAN fInstrument = TRUE;
BOOLEAN fFixed = FALSE;
s_nThread = GetCurrentThreadId();
printf("Ping Network Server: [" __DATE__ " " __TIME__ "]\n");
int arg = 1;
for (; arg < argc; arg++) {
if (argv[arg][0] == '-' || argv[arg][0] == '/') {
WCHAR *argn = argv[arg] + 1;
WCHAR *argp = argn;
while (*argp && *argp != ':') {
argp++;
}
if (*argp == ':') {
*argp++ = '\0';
}
switch (argn[0]) {
case 'f': // Fixed
case 'F':
fFixed = TRUE;
g_nFixedToClient = _wtoi(argp);
g_nFixedToServer = 0;
break;
case 'i':
case 'I': // Instrument
fInstrument = !fInstrument;
break;
case 'n': // Null
case 'N':
fFixed = TRUE;
g_nFixedToClient = g_nFixedToServer = 0;
break;
case 'l': // Long-term loop
case 'L':
fLong = !fLong;
break;
case 'p': // Profile Network
case 'P':
fProfile = !fProfile;
break;
case 's': // Server
case 'S':
fServer = !fServer;
break;
case 'u': // Unregister
case 'U':
fUnreg = !fUnreg;
break;
case 'x': // Xtract Data
case 'X':
g_fSummarize = !g_fSummarize;
break;
case '?': // Help
fNeedHelp = TRUE;
break;
case '\0': // Local Host
hr = StringCchCopyW(wzServers[nServers++], ARRAYSIZE(wzServers[nServers++]),
L"localhost");
if (FAILED(hr)) {
return 900;
}
ASSERT(nServers <= 32);
break;
default:
fNeedHelp = TRUE;
printf("Bad argument: %ls\n", argv[arg]);
break;
}
}
else {
hr = StringCchCopyW(wzServers[nServers++], ARRAYSIZE(wzServers[nServers++]), argv[arg]);
if (FAILED(hr)) {
return 900;
}
ASSERT(nServers <= 32);
}
}
if (argc == 1 || (nServers == 0 && !fUnreg && !fServer)) {
fNeedHelp = TRUE;
}
if (fNeedHelp) {
printf("Usage:\n"
" cping [options] [hosts] ..or.. cping [options] /s\n"
"Options:\n"
" /u : Unregister.\n"
" /s : Act as a server, waiting for clients.\n"
" /? : Display this help screen.\n"
"Client Options:\n"
" /l : Long-term loop test. (Default: %3s)\n"
" /p : Profile test. (Default: %3s)\n"
" /n : Null (0 length) test. (Default: Off)\n"
" /f:size : Fixed sized packets. (Default: %3s)\n"
" /x : Xtract detailed DCOM/RPC/NET data. (Default: %3s)\n"
" /i : Toggle instrumentation. (Default: %3s)\n",
fLong ? "On" : "Off",
fProfile ? "On" : "Off",
fFixed ? "On" : "Off",
g_fSummarize ? "Off" : "Off",
fInstrument ? "On" : "Off");
exit(1);
}
//////////////////////////////////////////////////////////////////////////
if (fUnreg) {
Unregister();
}
else {
//////////////////////////////////////////////////////////////////////////////
//
CInitStub cinitstub;
// Register in the registry.
Register();
if (fInstrument) {
RerouteEntryPoints();
}
LONGLONG llCycles;
hr = GetClockInfo(&llCycles);
ASSERT(SUCCEEDED(hr));
g_dCyclesPerSecond = (double)llCycles;
g_dMsPerCycle = (double)1000.0 / (double)llCycles;
g_pBuffer = CoTaskMemAlloc(g_cbBufferMax);
ASSERT(g_pBuffer != NULL);
if (fServer) {
// register the class-object with OLE
CNetPingFactory::InitSystem();
CNetPingFactory *pClassFactory = new CNetPingFactory;
printf("Registering.\n");
DWORD dwRegister;
hr = CoRegisterClassObject(CLSID_NetPingObject, pClassFactory,
CLSCTX_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
printf("Releasing Registered.\n");
pClassFactory->Release();
if (FAILED(hr)) {
CheckResult(hr, "Server: CoRegisterClassObject");
ASSERT(SUCCEEDED(hr));
}
printf(" Server: Waiting <<<Press Ctrl-C to stop.>>>\n");
while (fServer) {
CNetPingFactory::Wait();
}
hr = CoRevokeClassObject(dwRegister);
if (FAILED(hr)) {
CheckResult(hr, "Server: CoRevokeClassObject");
ASSERT(SUCCEEDED(hr));
}
CNetPingFactory::FiniSystem();
}
else if (nServers) {
LONGLONG llBeg;
LONGLONG llEnd;
COSERVERINFO csi;
MULTI_QI mq;
//////////////////////////////////////////////////////////////////
//
printf("Processor Speed: %.0f MHz\n", g_dCyclesPerSecond / 1000000.0);
DWORD dwSize = ARRAYSIZE(g_wzClientName);
GetComputerNameW(g_wzClientName, &dwSize);
printf(";;; %ls - %.0f MHz\n",
g_wzClientName,
g_dCyclesPerSecond / 1000000.0);
for (int n = 0; n < nServers; n++) {
if (g_wzServerName[0] == '\\' && g_wzServerName[1] == '\\') {
hr = StringCchCopyW(g_wzServerName, ARRAYSIZE(g_wzServerName), wzServers[n] + 2);
}
else {
hr = StringCchCopyW(g_wzServerName, ARRAYSIZE(g_wzServerName), wzServers[n]);
}
CheckResult(hr, "Main");
printf("Server: %ls->%ls\n", g_wzClientName, g_wzServerName);
printf(";; %ls %ls\n", g_wzClientName, g_wzServerName);
ZeroMemory(&csi, sizeof(csi));
csi.pwszName = wzServers[n];
// create a remote instance of the object on the argv[1] machine
mq.pIID = &IID_IPing;
mq.pItf = NULL;
mq.hr = S_OK;
llBeg = GetTimeStamp();
hr = CoCreateInstanceEx(CLSID_NetPingObject, NULL, CLSCTX_SERVER,
&csi, 1, &mq);
llEnd = GetTimeStamp();
printf(" CoCreateInstanceEx: %0.4f seconds (%lu ticks)\n",
(double)(llEnd - llBeg)/(double)llCycles,
(ULONG)(llEnd - llBeg));
CheckResult(mq.hr, "CoCreateInstanceEx [mq]");
CheckResult(hr, "CoCreateInstanceEx");
if (FAILED(hr)) {
CheckResult(hr, "CoCreateInstanceEx");
continue;
}
//////////////////////////////////////////////////////////////////
//
IPing *pIPing = (IPing *)mq.pItf;
hr = pIPing->Ping();
if (FAILED(hr)) {
CheckResult(hr, "Ping");
}
ASSERT(SUCCEEDED(hr));
hr = Catch_IPing_Ping(pIPing);
if (FAILED(hr)) {
CheckResult(hr, "Ping");
}
ASSERT(SUCCEEDED(hr));
ZeroCycles();
if (fFixed) {
Sample_Fixed(pIPing);
}
else if (fProfile) {
Sample_Profile(pIPing);
}
else {
Sample_Simple(pIPing);
if (fLong) {
for (;;) {
Sample_More(pIPing);
for (int j = 0; j < 5; j++) {
Sleep(20000);
Sample_Simple(pIPing);
}
Sleep(20000);
for (int i = 0; i < 18; i++) {
Sample_Less(pIPing);
for (int j = 0; j < 3; j++) {
Sleep(20000);
Sample_Simple(pIPing);
}
Sleep(20000);
}
}
}
}
pIPing->Release();
}
}
if (g_pBuffer) {
CoTaskMemFree(g_pBuffer);
g_pBuffer = NULL;
}
Sleep(2);
if (fInstrument && !g_fSummarize && s_rllCounts[E_Proxy]) {
printf("::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::"
"::::::::::::::::::\n");
printf(":: Instrumented Cycles: _____Function Time__ "
"________Total Time__ : Count\n");
LONG n = E_DCOM;
for (; n < E_MaxValue; n++) {
s_rllCycles[n] = 0;
s_rllTotals[n] = 0;
s_rllCounts[n] = 0;
}
for (n = E_MinValue + 1; n < E_MaxValue; n++) {
DumpCycles(n);
}
printf("::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::"
"::::::::::::::::::\n");
printf(":: Protocol Cycles:\n");
for (n = E_DcomBeg; n <= E_DcomEnd; n++) {
s_rllCycles[E_DCOM] += s_rllCycles[n];
s_rllTotals[E_DCOM] += s_rllTotals[n];
s_rllCounts[E_DCOM] += s_rllCounts[n];
}
for (n = E_RpcBeg; n <= E_RpcEnd; n++) {
s_rllCycles[E_RPC] += s_rllCycles[n];
s_rllTotals[E_RPC] += s_rllTotals[n];
s_rllCounts[E_RPC] += s_rllCounts[n];
}
for (n = E_UdpBeg; n <= E_UdpEnd; n++) {
s_rllCycles[E_UDP] += s_rllCycles[n];
s_rllTotals[E_UDP] += s_rllTotals[n];
s_rllCounts[E_UDP] += s_rllCounts[n];
}
for (n = E_NetBeg; n <= E_NetEnd; n++) {
s_rllTotals[E_NET] += s_rllCycles[n];
s_rllCycles[E_NET] += s_rllTotals[n];
s_rllCounts[E_NET] += s_rllCounts[n];
}
DumpCycles(E_DCOM);
DumpCycles(E_RPC);
DumpCycles(E_UDP);
DumpCycles(E_NET);
printf("::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::"
"::::::::::::::::::\n");
printf(":: Protocol Cycles Per DCOM Call:\n");
s_rllCycles[E_DCOM] /= s_rllCounts[E_DCOM];
s_rllCycles[E_RPC] /= s_rllCounts[E_DCOM];
s_rllCycles[E_UDP] /= s_rllCounts[E_DCOM];
s_rllCycles[E_NET] /= s_rllCounts[E_DCOM];
s_rllTotals[E_DCOM] /= s_rllCounts[E_DCOM];
s_rllTotals[E_RPC] /= s_rllCounts[E_DCOM];
s_rllTotals[E_UDP] /= s_rllCounts[E_DCOM];
s_rllTotals[E_NET] /= s_rllCounts[E_DCOM];
DumpCycles(E_DCOM);
DumpCycles(E_RPC);
DumpCycles(E_UDP);
DumpCycles(E_NET);
}
}
return 0;
}
//
///////////////////////////////////////////////////////////////// End of File.