windows-nt/Source/XPSP1/NT/ds/adsi/dbgexts/dbgmem.c

424 lines
11 KiB
C
Raw Normal View History

2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990 Microsoft Corporation
Module Name:
dbgsec.c
Abstract:
Argus debugging extensions. The routines here dump out Security Descriptors
and allow you to examine them.
Author:
Krishna Ganugapati (KrishnaG) 1-July-1993
Revision History:
KrishnaG: Created: 1-July-1993 (imported most of IanJa's stuff)
KrishnaG: Added: 7-July-1993 (added AndrewBe's UnicodeAnsi conversion
KrishnaG Added: 3-Aug-1993 (added DevMode/SecurityDescriptor dumps)
t-blakej Added: 1-July-1997 (added single-address dump, PID)
To do:
--*/
#define NOMINMAX
#define SECURITY_WIN32
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <stdlib.h>
#include <math.h>
#include <ntsdexts.h>
#include <windows.h>
#include <winspool.h>
#include <security.h>
#include <wchar.h>
#include <winldap.h>
#include "dbglocal.h"
#define NULL_TERMINATED 0
#define MAXDEPTH 10
typedef struct _ADSMEMTAG {
DWORD Tag ;
DWORD Size ;
PVOID pvBackTrace[MAXDEPTH+1];
LPSTR pszSymbol[MAXDEPTH+1];
DWORD uDepth;
LIST_ENTRY List ;
} ADSMEMTAG, *PADSMEMTAG ;
typedef struct _ADS_LDP {
LIST_ENTRY List ;
LPWSTR Server ;
ULONG RefCount ;
LUID Luid ;
DWORD Flags ;
LDAP *LdapHandle ;
PVOID *pCredentials;
DWORD PortNumber;
DWORD TickCount ;
PVOID **ReferralEntries;
DWORD nReferralEntries;
} ADS_LDP, *PADS_LDP ;
ULONG
TranslateAddress (
IN DWORD dwProcessId,
IN ULONG Address,
OUT LPSTR Name,
IN ULONG MaxNameLength
);
void print_struct_ldap(
HANDLE hCurrentProcess,
HANDLE hCurrentThread,
DWORD dwCurrentPc,
PNTSD_EXTENSION_APIS lpExtensionApis,
LDAP ldap_struct);
DWORD
SimpleAToI(LPSTR *lppStr)
{
DWORD dwResult = 0;
while (isspace(**lppStr)) (*lppStr)++;
while (isdigit(**lppStr))
{
dwResult = dwResult * 10 + (**lppStr - '0');
(*lppStr)++;
}
return dwResult;
}
BOOL
dmem(
HANDLE hCurrentProcess,
HANDLE hCurrentThread,
DWORD dwCurrentPc,
PNTSD_EXTENSION_APIS lpExtensionApis,
LPSTR lpArgumentString)
{
PNTSD_OUTPUT_ROUTINE Print;
PNTSD_GET_EXPRESSION EvalExpression;
PNTSD_GET_SYMBOL GetSymbol;
DWORD Address = (DWORD)NULL;
DWORD dwProcessId = 0;
BOOL bThereAreOptions = TRUE;
BOOL bDoOneAddress = FALSE;
LIST_ENTRY ListEntry;
LIST_ENTRY AdsMemHeader;
ADSMEMTAG AdsMemTag;
DWORD pEntry = 0;
DWORD pTemp = 0;
DWORD pMem = 0;
CHAR szSymbolName[MAX_PATH];
DWORD i = 0;
UNREFERENCED_PARAMETER(hCurrentProcess);
UNREFERENCED_PARAMETER(hCurrentThread);
UNREFERENCED_PARAMETER(dwCurrentPc);
Print = lpExtensionApis->lpOutputRoutine;
EvalExpression = lpExtensionApis->lpGetExpressionRoutine;
GetSymbol = lpExtensionApis->lpGetSymbolRoutine;
dwProcessId = GetCurrentProcessId();
while (bThereAreOptions) {
while (isspace(*lpArgumentString)) {
lpArgumentString++;
}
switch (*lpArgumentString) {
//
// Read symbols from the process whose PID is an arg to "p".
//
case 'p':
lpArgumentString++;
// EvalValue uses hex, and I don't want to bother fiddling with
// it enough to make it do decimal.
dwProcessId = SimpleAToI(&lpArgumentString);
break;
//
// Dump the single address given as an arg to "a".
//
case 'a':
lpArgumentString++;
Address = EvalValue(&lpArgumentString, EvalExpression, Print);
bDoOneAddress = TRUE;
break;
default: // go get the address because there's nothing else
bThereAreOptions = FALSE;
break;
}
}
if (!bDoOneAddress) {
if (*lpArgumentString != 0) {
Address = EvalValue(&lpArgumentString, EvalExpression, Print);
}
// if we've got no address, then quit now - nothing we can do
if (Address == (DWORD)NULL) {
Print("We have a Null address\n");
return(0);
}
movestruct(Address, &AdsMemHeader, LIST_ENTRY);
pEntry = AdsMemHeader.Flink;
while(pEntry != Address) {
movestruct(pEntry, &ListEntry, LIST_ENTRY);
pTemp = (BYTE*)pEntry;
pTemp = pTemp - sizeof(DWORD) - sizeof(DWORD)
- sizeof(DWORD) -
(sizeof(CHAR*) + sizeof(LPVOID))*( MAXDEPTH +1);
pMem = (ADSMEMTAG*)pTemp;
movestruct(pMem, &AdsMemTag, ADSMEMTAG);
Print("[oleds] Memory leak!!! size = %ld\n", AdsMemTag.Size);
for (i = 0; i < AdsMemTag.uDepth; i++) {
TranslateAddress(dwProcessId, AdsMemTag.pvBackTrace[i],
szSymbolName, 256);
Print("%.8x %s\n", AdsMemTag.pvBackTrace[i], szSymbolName);
}
Print("\n");
pEntry = ListEntry.Flink;
}
}
else {
TranslateAddress(dwProcessId, Address, szSymbolName, 256);
Print("%.8x %s\n", Address, szSymbolName);
}
return 0;
DBG_UNREFERENCED_PARAMETER(hCurrentProcess);
DBG_UNREFERENCED_PARAMETER(hCurrentThread);
DBG_UNREFERENCED_PARAMETER(dwCurrentPc);
}
//
// Give it the adsldpc!BindCache address and it will give
// the BindCache info.
//
BOOL
dcache(
HANDLE hCurrentProcess,
HANDLE hCurrentThread,
DWORD dwCurrentPc,
PNTSD_EXTENSION_APIS lpExtensionApis,
LPSTR lpArgumentString)
{
PNTSD_OUTPUT_ROUTINE Print;
PNTSD_GET_EXPRESSION EvalExpression;
PNTSD_GET_SYMBOL GetSymbol;
DWORD Address = (DWORD)NULL;
DWORD dwProcessId = 0;
BOOL bThereAreOptions = TRUE;
BOOL bDoOneAddress = FALSE;
ADS_LDP BindCacheEntry;
ADS_LDP ads_ldp_struct;
DWORD pEntry = 0;
DWORD pTemp = 0;
ADS_LDP *pMem = NULL;
CHAR szSymbolName[MAX_PATH];
LDAP LDAPStruct;
DWORD i = 0;
WCHAR serverName[250];
//DebugBreak();
UNREFERENCED_PARAMETER(hCurrentProcess);
UNREFERENCED_PARAMETER(hCurrentThread);
UNREFERENCED_PARAMETER(dwCurrentPc);
Print = lpExtensionApis->lpOutputRoutine;
EvalExpression = lpExtensionApis->lpGetExpressionRoutine;
GetSymbol = lpExtensionApis->lpGetSymbolRoutine;
dwProcessId = GetCurrentProcessId();
while (bThereAreOptions) {
while (isspace(*lpArgumentString)) {
lpArgumentString++;
}
switch (*lpArgumentString) {
//
// Read symbols from the process whose PID is an arg to "p".
//
case 'p':
lpArgumentString++;
// EvalValue uses hex, and I don't want to bother fiddling with
// it enough to make it do decimal.
dwProcessId = SimpleAToI(&lpArgumentString);
break;
//
// Dump the single address given as an arg to "a".
//
case 'a':
lpArgumentString++;
Address = EvalValue(&lpArgumentString, EvalExpression, Print);
bDoOneAddress = TRUE;
break;
default: // go get the address because there's nothing else
bThereAreOptions = FALSE;
break;
}
}
if (!bDoOneAddress) {
if (*lpArgumentString != 0) {
Address = EvalValue(&lpArgumentString, EvalExpression, Print);
}
// if we've got no address, then quit now - nothing we can do
if (Address == (DWORD)NULL) {
Print("We have a Null address\n");
return(0);
}
movestruct(Address, &BindCacheEntry, LIST_ENTRY);
pEntry = BindCacheEntry.List.Flink;
Print("Bind Cache Address passed is 0x%x\n", pEntry);
while(pEntry != Address) {
movestruct(pEntry, &BindCacheEntry, ADS_LDP);
movemem(BindCacheEntry.Server, serverName, 250);
// get the LDAP struct also now
movestruct(BindCacheEntry.LdapHandle, &LDAPStruct, LDAP);
Print("BindCache Information :\n");
Print(" Server : %S\n", serverName);
Print(" RefCount : %lu\n", BindCacheEntry.RefCount);
Print(" LUID.High : %ld\n", BindCacheEntry.Luid.HighPart);
Print(" LUID.Low : %ld\n", BindCacheEntry.Luid.LowPart);
Print(" FLAGS : %ld\n", BindCacheEntry.Flags);
Print(" LDAPHandle :0x%X\n", BindCacheEntry.LdapHandle);
print_struct_ldap(
hCurrentProcess,
hCurrentThread,
dwCurrentPc,
lpExtensionApis,
LDAPStruct);
Print(" pCredenti : 0x%X\n", BindCacheEntry.pCredentials);
Print(" PortNo : %ld\n", BindCacheEntry.PortNumber);
Print(" Referrals : %ld\n", BindCacheEntry.nReferralEntries);
pEntry = BindCacheEntry.List.Flink;
}
}
else {
TranslateAddress(dwProcessId, Address, szSymbolName, 256);
Print("%.8x %s\n", Address, szSymbolName);
}
return 0;
DBG_UNREFERENCED_PARAMETER(hCurrentProcess);
DBG_UNREFERENCED_PARAMETER(hCurrentThread);
DBG_UNREFERENCED_PARAMETER(dwCurrentPc);
}
void print_struct_ldap(
HANDLE hCurrentProcess,
HANDLE hCurrentThread,
DWORD dwCurrentPc,
PNTSD_EXTENSION_APIS lpExtensionApis,
LDAP ldap_struct)
{
PNTSD_OUTPUT_ROUTINE Print;
UCHAR u_char_string[250];
Print = lpExtensionApis->lpOutputRoutine;
if (ldap_struct.ld_host) {
movemem(ldap_struct.ld_host, u_char_string, 250);
Print(" ld_host, address : 0x%X, string value: %s\n",
ldap_struct.ld_host, u_char_string);
}
Print(" ld_version : %lu\n", ldap_struct.ld_version);
Print(" ld_lberoptions (UCHAR) : %c\n",
ldap_struct.ld_lberoptions);
Print(" ld_deref : %lu\n", ldap_struct.ld_deref);
Print(" ld_timelimit : %lu\n", ldap_struct.ld_timelimit);
Print(" ld_sizelimit : %lu\n", ldap_struct.ld_sizelimit);
Print(" ld_errno : %lu\n", ldap_struct.ld_errno);
if (ldap_struct.ld_matched) {
movemem(ldap_struct.ld_matched, u_char_string, 250);
Print(" ld_matched address : 0x%X, string value: %s\n",
ldap_struct.ld_matched, u_char_string);
}
if (ldap_struct.ld_error) {
movemem(ldap_struct.ld_error, u_char_string, 250);
Print(" ld_error address : 0x%X, string value: %s\n",
ldap_struct.ld_error, u_char_string);
}
Print(" ld_msgid : %lu\n", ldap_struct.ld_msgid);
Print(" ld_cldaptries : %lu\n", ldap_struct.ld_cldaptries);
Print(" ld_cldaptimeout : %lu\n", ldap_struct.ld_cldaptimeout);
Print(" ld_refhoplimit : %lu\n", ldap_struct.ld_refhoplimit);
Print(" ld_options : %lu\n", ldap_struct.ld_options);
}