1957 lines
62 KiB
C
1957 lines
62 KiB
C
/*++
|
|
|
|
Copyright (c) 1990 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dfskd.c
|
|
|
|
Abstract:
|
|
|
|
Dfs Kernel Debugger extension
|
|
|
|
Author:
|
|
|
|
Milan Shah (milans) 21-Aug-1995
|
|
|
|
Revision History:
|
|
|
|
21-Aug-1995 Milans Created
|
|
30-Aug-1997 JHarper Updated
|
|
|
|
--*/
|
|
|
|
#include <ntos.h>
|
|
#include <nturtl.h>
|
|
#include "ntverp.h"
|
|
|
|
#include <windows.h>
|
|
#include <wdbgexts.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
#include "nodetype.h"
|
|
#include "dfsmrshl.h"
|
|
#include "dfsfsctl.h"
|
|
#include "pkt.h"
|
|
#include "dfslpc.h"
|
|
#include "spcsup.h"
|
|
#include "sitesup.h"
|
|
#include "ipsup.h"
|
|
#include "dfsstruc.h"
|
|
#include "fsctrl.h"
|
|
#include "attach.h"
|
|
#include "fcbsup.h"
|
|
|
|
#include <kdextlib.h>
|
|
|
|
#define PRINTF dprintf
|
|
#define IPRINTF DoIndent(); dprintf
|
|
#define IPRINTSTRINGW DoIndent(); wPrintStringW
|
|
#define NTC_UNDEFINED ((NODE_TYPE_CODE)0x0000)
|
|
|
|
#define DSFS_NTC_DATA_HEADER ((NODE_TYPE_CODE)0x0D01)
|
|
#define DSFS_NTC_IRP_CONTEXT ((NODE_TYPE_CODE)0x0D02)
|
|
#define DSFS_NTC_REFERRAL ((NODE_TYPE_CODE)0x0D03)
|
|
#define DSFS_NTC_VCB ((NODE_TYPE_CODE)0x0D04)
|
|
#define DSFS_NTC_PROVIDER ((NODE_TYPE_CODE)0x0D05)
|
|
#define DSFS_NTC_FCB_HASH ((NODE_TYPE_CODE)0x0D06)
|
|
#define DSFS_NTC_FCB ((NODE_TYPE_CODE)0x0D07)
|
|
#define DSFS_NTC_DNR_CONTEXT ((NODE_TYPE_CODE)0x0D08)
|
|
#define DSFS_NTC_PKT ((NODE_TYPE_CODE)0x0D09)
|
|
#define DSFS_NTC_PKT_ENTRY ((NODE_TYPE_CODE)0x0D0A)
|
|
#define DSFS_NTC_PKT_STUB ((NODE_TYPE_CODE)0x0D0B)
|
|
#define DSFS_NTC_INSTRUM ((NODE_TYPE_CODE)0x0D0C)
|
|
#define DSFS_NTC_INSTRUM_FREED ((NODE_TYPE_CODE)0x0D0D)
|
|
#define DSFS_NTC_PWSTR ((NODE_TYPE_CODE)0x0D0E)
|
|
|
|
#define FIELD_NAME_LENGTH 30
|
|
#define NewLineForFields(FieldNo) \
|
|
((((FieldNo) % s_NoOfColumns) == 0) ? NewLine : FieldSeparator)
|
|
char *NewLine = "\n";
|
|
char *FieldSeparator = " ";
|
|
|
|
BOOLEAN wGetData( ULONG_PTR dwAddress, PVOID ptr, ULONG size);
|
|
BOOL wGetString( ULONG_PTR dwAddress, PSZ buf );
|
|
BOOL wPrintStringW( IN LPSTR msg OPTIONAL, IN PUNICODE_STRING pStr, IN BOOL nl );
|
|
BOOL wPrintStringA( IN LPSTR msg OPTIONAL, IN PANSI_STRING pStr, IN BOOL nl );
|
|
BOOL wPrintLargeInt(LARGE_INTEGER *bigint);
|
|
|
|
#define MAX_ENTRIES 100
|
|
|
|
/*
|
|
* Dfs global variables.
|
|
*
|
|
*/
|
|
|
|
#define NO_SYMBOLS_MESSAGE \
|
|
"Unable to get address of Dfs!DfsData - do you have symbols?\n"
|
|
|
|
LPSTR ExtensionNames[] = {
|
|
"Dfs debugger extensions",
|
|
0
|
|
};
|
|
|
|
LPSTR Extensions[] = {
|
|
"DfsData - dumps Dfs!DfsData",
|
|
"Pkt - dumps the global Pkt",
|
|
"SpecialTable - dumps the Special table",
|
|
"FtDfsTable - dumps the FtDfs table",
|
|
"SiteTable - dumps the Site table",
|
|
"IpTable - dumps the Ip table",
|
|
"FcbTable - dumps all the Dfs FCBs",
|
|
"VdoList - dumps all the Dfs Volume Objects (attached device objects)",
|
|
"VcbList - dumps all the Vcbs & Dfs Device Objects (net used objects)",
|
|
"Dump - dump a data structure. Type in 'dfskd.dump' for more info",
|
|
"Dumpdfs address -- dumps DfsData, prefix table",
|
|
0
|
|
};
|
|
|
|
ENUM_VALUE_DESCRIPTOR DfsOperationalStateEnum[] = {
|
|
{DFS_STATE_UNINITIALIZED, "Dfs State Uninitialized"},
|
|
{DFS_STATE_INITIALIZED, "Dfs State Initialized"},
|
|
{DFS_STATE_STARTED, "Dfs Started"},
|
|
{DFS_STATE_STOPPING, "Dfs Stopping"},
|
|
{DFS_STATE_STOPPED, "Dfs Stopped"},
|
|
0
|
|
};
|
|
|
|
ENUM_VALUE_DESCRIPTOR DfsMachineStateEnum[] = {
|
|
{DFS_UNKNOWN, "Dfs State Unknown"},
|
|
{DFS_CLIENT, "Dfs Client"},
|
|
{DFS_SERVER, "Dfs Server"},
|
|
{DFS_ROOT_SERVER, "Dfs Root"},
|
|
0
|
|
};
|
|
|
|
ENUM_VALUE_DESCRIPTOR LpcPortStateEnum[] = {
|
|
{LPC_STATE_UNINITIALIZED, "Unitialized"},
|
|
{LPC_STATE_INITIALIZING, "Initializing"},
|
|
{LPC_STATE_INITIALIZED, "Initialized"},
|
|
0
|
|
};
|
|
|
|
ENUM_VALUE_DESCRIPTOR LvStateEnum[] = {
|
|
{LV_UNINITIALIZED,"Local Vols Uninitialized"},
|
|
{LV_INITSCHEDULED,"Local Vols init scheduled"},
|
|
{LV_INITINPROGRESS,"Local Vols init in progress"},
|
|
{LV_INITIALIZED,"Local Vols Initialized"},
|
|
{LV_VALIDATED,"Local Vols Validated with DC"},
|
|
0
|
|
};
|
|
|
|
/*
|
|
* DFS_DATA
|
|
*
|
|
*/
|
|
|
|
FIELD_DESCRIPTOR DfsDataFields[] = {
|
|
FIELD3(FieldTypeShort,DFS_DATA,NodeTypeCode),
|
|
FIELD3(FieldTypeShort,DFS_DATA,NodeByteSize),
|
|
FIELD3(FieldTypeStruct,DFS_DATA,AVdoQueue),
|
|
FIELD3(FieldTypePointer,DFS_DATA,DriverObject),
|
|
FIELD3(FieldTypePointer,DFS_DATA,FileSysDeviceObject),
|
|
FIELD3(FieldTypePointer,DFS_DATA,pProvider),
|
|
FIELD3(FieldTypeULong,DFS_DATA,cProvider),
|
|
FIELD3(FieldTypeULong,DFS_DATA,maxProvider),
|
|
FIELD3(FieldTypeStruct,DFS_DATA,Resource),
|
|
FIELD3(FieldTypeUnicodeString,DFS_DATA,PrincipalName),
|
|
FIELD3(FieldTypeUnicodeString,DFS_DATA,NetBIOSName),
|
|
FIELD4(FieldTypeEnum,DFS_DATA,OperationalState,DfsOperationalStateEnum),
|
|
FIELD4(FieldTypeEnum,DFS_DATA,MachineState,DfsMachineStateEnum),
|
|
FIELD3(FieldTypeBoolean,DFS_DATA,IsDC),
|
|
FIELD4(FieldTypeEnum,DFS_DATA,LvState,LvStateEnum),
|
|
FIELD3(FieldTypeStruct,DFS_DATA,Pkt),
|
|
FIELD3(FieldTypePointer,DFS_DATA,FcbHashTable),
|
|
FIELD3(FieldTypePointer,DFS_DATA,SiteHashTable),
|
|
FIELD3(FieldTypePointer,DFS_DATA,IpHashTable),
|
|
FIELD3(FieldTypePointer,DFS_DATA,SpcHashTable),
|
|
FIELD3(FieldTypePointer,DFS_DATA,FtDfsHashTable),
|
|
FIELD3(FieldTypeStruct,DFS_DATA,DfsLpcInfo),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* DFS_PKT
|
|
*
|
|
*/
|
|
|
|
FIELD_DESCRIPTOR DfsPktFields[] = {
|
|
FIELD3(FieldTypeUShort,DFS_PKT,NodeTypeCode),
|
|
FIELD3(FieldTypeUShort,DFS_PKT,NodeByteSize),
|
|
FIELD3(FieldTypeStruct,DFS_PKT,Resource),
|
|
FIELD3(FieldTypeStruct,DFS_PKT,UseCountLock),
|
|
FIELD3(FieldTypeULong,DFS_PKT,EntryCount),
|
|
FIELD3(FieldTypeStruct,DFS_PKT,EntryList),
|
|
FIELD3(FieldTypePointer,DFS_PKT,DomainPktEntry),
|
|
FIELD3(FieldTypeStruct,DFS_PKT,LocalVolTable),
|
|
FIELD3(FieldTypeStruct,DFS_PKT,PrefixTable),
|
|
FIELD3(FieldTypeStruct,DFS_PKT,ShortPrefixTable),
|
|
FIELD3(FieldTypeStruct,DFS_PKT,DSMachineTable),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* DFS_PKT_ENTRY
|
|
*
|
|
*/
|
|
|
|
BIT_MASK_DESCRIPTOR PktEntryType[] = {
|
|
{PKT_ENTRY_TYPE_CAIRO, "Cairo Volume"},
|
|
{PKT_ENTRY_TYPE_MACHINE, "Machine Volume"},
|
|
{PKT_ENTRY_TYPE_NONCAIRO, "Non-Cairo Volume"},
|
|
{PKT_ENTRY_TYPE_OUTSIDE_MY_DOM, "Inter-Domain Volume"},
|
|
{PKT_ENTRY_TYPE_REFERRAL_SVC, "Referral Service (DC)"},
|
|
{PKT_ENTRY_TYPE_PERMANENT, "Permanent Entry"},
|
|
{PKT_ENTRY_TYPE_LOCAL,"Local Volume"},
|
|
{PKT_ENTRY_TYPE_LOCAL_XPOINT,"Local Exit Point"},
|
|
{PKT_ENTRY_TYPE_MACH_SHARE,"Local Machine Share"},
|
|
{PKT_ENTRY_TYPE_OFFLINE,"Offline Volume"},
|
|
0
|
|
};
|
|
|
|
FIELD_DESCRIPTOR DfsPktEntryFields[] = {
|
|
FIELD3(FieldTypeUShort,DFS_PKT_ENTRY,NodeTypeCode),
|
|
FIELD3(FieldTypeUShort,DFS_PKT_ENTRY,NodeByteSize),
|
|
FIELD4(FieldTypeDWordBitMask,DFS_PKT_ENTRY,Type,PktEntryType),
|
|
FIELD3(FieldTypeULong,DFS_PKT_ENTRY,USN),
|
|
FIELD3(FieldTypeUnicodeString,DFS_PKT_ENTRY,Id.Prefix),
|
|
FIELD3(FieldTypeUnicodeString,DFS_PKT_ENTRY,Id.ShortPrefix),
|
|
FIELD3(FieldTypeULong,DFS_PKT_ENTRY,Info.Timeout),
|
|
FIELD3(FieldTypeULong,DFS_PKT_ENTRY,Info.ServiceCount),
|
|
FIELD3(FieldTypePointer,DFS_PKT_ENTRY,Info.ServiceList),
|
|
FIELD3(FieldTypeULong,DFS_PKT_ENTRY,UseCount),
|
|
FIELD3(FieldTypeULong,DFS_PKT_ENTRY,FileOpenCount),
|
|
FIELD3(FieldTypePointer,DFS_PKT_ENTRY,ActiveService),
|
|
FIELD3(FieldTypePointer,DFS_PKT_ENTRY,LocalService),
|
|
FIELD3(FieldTypePointer,DFS_PKT_ENTRY,Superior),
|
|
FIELD3(FieldTypeULong,DFS_PKT_ENTRY,SubordinateCount),
|
|
FIELD3(FieldTypeStruct,DFS_PKT_ENTRY,SubordinateList),
|
|
FIELD3(FieldTypeStruct,DFS_PKT_ENTRY,SiblingLink),
|
|
FIELD3(FieldTypePointer,DFS_PKT_ENTRY,ClosestDC),
|
|
FIELD3(FieldTypeStruct,DFS_PKT_ENTRY,ChildList),
|
|
FIELD3(FieldTypeStruct,DFS_PKT_ENTRY,NextLink),
|
|
FIELD3(FieldTypeStruct,DFS_PKT_ENTRY,PrefixTableEntry),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* DFS_SERVICE
|
|
*
|
|
*/
|
|
|
|
BIT_MASK_DESCRIPTOR ServiceType[] = {
|
|
{DFS_SERVICE_TYPE_MASTER, "Master Svc"},
|
|
{DFS_SERVICE_TYPE_READONLY, "Read-Only Svc"},
|
|
{DFS_SERVICE_TYPE_LOCAL, "Local Svc"},
|
|
{DFS_SERVICE_TYPE_REFERRAL, "Referral Svc"},
|
|
{DFS_SERVICE_TYPE_ACTIVE, "Active Svc"},
|
|
{DFS_SERVICE_TYPE_DOWN_LEVEL, "Down-level Svc"},
|
|
{DFS_SERVICE_TYPE_COSTLIER, "Costlier than previous"},
|
|
{DFS_SERVICE_TYPE_OFFLINE, "Svc Offline"},
|
|
0
|
|
};
|
|
|
|
BIT_MASK_DESCRIPTOR ServiceCapability[] = {
|
|
{PROV_DFS_RDR, "Use Dfs Rdr"},
|
|
{PROV_STRIP_PREFIX, "Strip Prefix (downlevel or local) Svc"},
|
|
0
|
|
};
|
|
|
|
|
|
FIELD_DESCRIPTOR DfsServiceFields[] = {
|
|
FIELD4(FieldTypeDWordBitMask,DFS_SERVICE,Type,ServiceType),
|
|
FIELD4(FieldTypeDWordBitMask,DFS_SERVICE,Capability,ServiceCapability),
|
|
FIELD3(FieldTypeULong,DFS_SERVICE,Status),
|
|
FIELD3(FieldTypeULong,DFS_SERVICE,ProviderId),
|
|
FIELD3(FieldTypeULong,DFS_SERVICE,Cost),
|
|
FIELD3(FieldTypePointer,DFS_SERVICE,ConnFile),
|
|
FIELD3(FieldTypePointer,DFS_SERVICE,pProvider),
|
|
FIELD3(FieldTypePointer,DFS_SERVICE,pMachEntry),
|
|
FIELD3(FieldTypeUnicodeString,DFS_SERVICE,Name),
|
|
FIELD3(FieldTypeUnicodeString,DFS_SERVICE,Address),
|
|
FIELD3(FieldTypeUnicodeString,DFS_SERVICE,StgId),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* DFS_MACHINE_ENTRY
|
|
*
|
|
*/
|
|
|
|
FIELD_DESCRIPTOR DfsMachineEntryFields[] = {
|
|
FIELD3(FieldTypePointer,DFS_MACHINE_ENTRY,pMachine),
|
|
FIELD3(FieldTypeUnicodeString,DFS_MACHINE_ENTRY,MachineName),
|
|
FIELD3(FieldTypeULong,DFS_MACHINE_ENTRY,UseCount),
|
|
FIELD3(FieldTypeULong,DFS_MACHINE_ENTRY,ConnectionCount),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* DS_MACHINE
|
|
*
|
|
*/
|
|
|
|
FIELD_DESCRIPTOR DsMachineFields[] = {
|
|
FIELD3(FieldTypeGuid,DS_MACHINE,guidSite),
|
|
FIELD3(FieldTypeGuid,DS_MACHINE,guidMachine),
|
|
FIELD3(FieldTypeULong,DS_MACHINE,grfFlags),
|
|
FIELD3(FieldTypePWStr,DS_MACHINE,pwszShareName),
|
|
FIELD3(FieldTypeULong,DS_MACHINE,cPrincipals),
|
|
FIELD3(FieldTypePointer,DS_MACHINE,prgpwszPrincipals),
|
|
FIELD3(FieldTypeULong,DS_MACHINE,cTransports),
|
|
FIELD3(FieldTypeStruct,DS_MACHINE,rpTrans),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* DFS_LPC_INFO
|
|
*
|
|
*/
|
|
|
|
FIELD_DESCRIPTOR LpcInfoFields[] = {
|
|
FIELD3(FieldTypeUnicodeString,DFS_LPC_INFO,LpcPortName),
|
|
FIELD4(FieldTypeEnum,DFS_LPC_INFO,LpcPortState,LpcPortStateEnum),
|
|
FIELD3(FieldTypePointer,DFS_LPC_INFO,LpcPortHandle),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* PROVIDER_DEF
|
|
*
|
|
*/
|
|
|
|
FIELD_DESCRIPTOR ProviderDefFields[] = {
|
|
FIELD3(FieldTypeUShort,PROVIDER_DEF,NodeTypeCode),
|
|
FIELD3(FieldTypeUShort,PROVIDER_DEF,NodeByteSize),
|
|
FIELD3(FieldTypeUShort,PROVIDER_DEF,eProviderId),
|
|
FIELD4(FieldTypeDWordBitMask,PROVIDER_DEF,fProvCapability,ServiceCapability),
|
|
FIELD3(FieldTypeUnicodeString,PROVIDER_DEF,DeviceName),
|
|
FIELD3(FieldTypePointer,PROVIDER_DEF,DeviceObject),
|
|
FIELD3(FieldTypePointer,PROVIDER_DEF,FileObject),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* DFS_VOLUME_OBJECT
|
|
*
|
|
*/
|
|
|
|
FIELD_DESCRIPTOR DfsVolumeObjectFields[] = {
|
|
FIELD3(FieldTypeStruct,DFS_VOLUME_OBJECT,DeviceObject),
|
|
FIELD3(FieldTypeULong,DFS_VOLUME_OBJECT,AttachCount),
|
|
FIELD3(FieldTypeStruct,DFS_VOLUME_OBJECT,VdoLinks),
|
|
FIELD3(FieldTypeStruct,DFS_VOLUME_OBJECT,Provider),
|
|
FIELD3(FieldTypeUnicodeString,DFS_VOLUME_OBJECT,Provider.DeviceName),
|
|
FIELD3(FieldTypePointer,DFS_VOLUME_OBJECT,Provider.DeviceObject),
|
|
FIELD3(FieldTypePointer,DFS_VOLUME_OBJECT,Provider.FileObject),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* DFS_PREFIX_TABLE
|
|
*
|
|
*/
|
|
|
|
FIELD_DESCRIPTOR DfsPrefixTableFields[] = {
|
|
FIELD3(FieldTypeBoolean,DFS_PREFIX_TABLE,CaseSensitive),
|
|
FIELD3(FieldTypePointer,DFS_PREFIX_TABLE,NamePageList.pFirstPage),
|
|
FIELD3(FieldTypePointer,DFS_PREFIX_TABLE,NextEntry),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,RootEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[0].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[0].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[1].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[1].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[2].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[2].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[3].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[3].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[4].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[4].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[5].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[5].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[6].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[6].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[7].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[7].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[8].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[8].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[9].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[9].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[10].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[10].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[11].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[11].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[12].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[12].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[13].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[13].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[14].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[14].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[15].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[15].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[16].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[16].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[17].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[17].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[18].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[18].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[19].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[19].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[20].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[20].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[21].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[21].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[22].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[22].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[23].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[23].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[24].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[24].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[25].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[25].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[26].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[26].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[27].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[27].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[28].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[28].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[29].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[29].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[30].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[30].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[31].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[31].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[32].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[32].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[33].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[33].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[34].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[34].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[35].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[35].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[36].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[36].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[37].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[37].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[38].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[38].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[39].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[39].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[40].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[40].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[41].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[41].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[42].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[42].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[43].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[43].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[44].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[44].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[45].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[45].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[46].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[46].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[47].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[47].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[48].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[48].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[49].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[49].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[50].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[50].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[51].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[51].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[52].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[52].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[53].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[53].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[54].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[54].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[55].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[55].SentinelEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE,Buckets[56].NoOfEntries),
|
|
FIELD3(FieldTypeStruct,DFS_PREFIX_TABLE,Buckets[56].SentinelEntry),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* DFS_PREFIX_TABLE_ENTRY
|
|
*
|
|
*/
|
|
|
|
FIELD_DESCRIPTOR DfsPrefixTableEntryFields[] = {
|
|
FIELD3(FieldTypePointer,DFS_PREFIX_TABLE_ENTRY,pParentEntry),
|
|
FIELD3(FieldTypePointer,DFS_PREFIX_TABLE_ENTRY,pNextEntry),
|
|
FIELD3(FieldTypePointer,DFS_PREFIX_TABLE_ENTRY,pPrevEntry),
|
|
FIELD3(FieldTypePointer,DFS_PREFIX_TABLE_ENTRY,pFirstChildEntry),
|
|
FIELD3(FieldTypePointer,DFS_PREFIX_TABLE_ENTRY,pSiblingEntry),
|
|
FIELD3(FieldTypeULong,DFS_PREFIX_TABLE_ENTRY,NoOfChildren),
|
|
FIELD3(FieldTypeUnicodeString,DFS_PREFIX_TABLE_ENTRY,PathSegment),
|
|
FIELD3(FieldTypePointer,DFS_PREFIX_TABLE_ENTRY,pData),
|
|
0
|
|
};
|
|
|
|
FIELD_DESCRIPTOR DfsLocalVolEntryFields[] = {
|
|
FIELD3(FieldTypeStruct,DFS_LOCAL_VOL_ENTRY,PktEntry),
|
|
FIELD3(FieldTypeUnicodeString,DFS_LOCAL_VOL_ENTRY,LocalPath),
|
|
FIELD3(FieldTypeUnicodeString,DFS_LOCAL_VOL_ENTRY,ShareName),
|
|
FIELD3(FieldTypeStruct,DFS_LOCAL_VOL_ENTRY,PrefixTableEntry),
|
|
0
|
|
};
|
|
|
|
|
|
/*
|
|
* DFS_FCB
|
|
*
|
|
*/
|
|
|
|
FIELD_DESCRIPTOR FcbFields[] = {
|
|
FIELD3(FieldTypeUShort, DFS_FCB, NodeTypeCode),
|
|
FIELD3(FieldTypeUShort, DFS_FCB, NodeByteSize),
|
|
FIELD3(FieldTypeUnicodeString, DFS_FCB, FullFileName),
|
|
FIELD3(FieldTypePointer, DFS_FCB, FileObject),
|
|
0
|
|
};
|
|
|
|
|
|
STRUCT_DESCRIPTOR Structs[] = {
|
|
STRUCT(DFS_DATA,DfsDataFields),
|
|
STRUCT(DFS_PKT,DfsPktFields),
|
|
STRUCT(DFS_PKT_ENTRY,DfsPktEntryFields),
|
|
STRUCT(DFS_SERVICE,DfsServiceFields),
|
|
STRUCT(DFS_MACHINE_ENTRY,DfsMachineEntryFields),
|
|
STRUCT(DS_MACHINE,DsMachineFields),
|
|
STRUCT(PROVIDER_DEF,ProviderDefFields),
|
|
STRUCT(DFS_VOLUME_OBJECT,DfsVolumeObjectFields),
|
|
STRUCT(DFS_PREFIX_TABLE,DfsPrefixTableFields),
|
|
STRUCT(DFS_PREFIX_TABLE_ENTRY,DfsPrefixTableEntryFields),
|
|
STRUCT(DFS_LOCAL_VOL_ENTRY,DfsLocalVolEntryFields),
|
|
STRUCT(DFS_LPC_INFO,LpcInfoFields),
|
|
STRUCT(DFS_FCB,FcbFields),
|
|
0
|
|
};
|
|
|
|
/*
|
|
* Dfs specific dump routines
|
|
*
|
|
*/
|
|
|
|
|
|
VOID
|
|
dumplist(
|
|
ULONG_PTR dwListEntryAddress,
|
|
DWORD linkOffset,
|
|
VOID (*dumpRoutine)(ULONG_PTR dwStructAddress)
|
|
);
|
|
|
|
VOID
|
|
dumpPktEntry(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
PktEntryDump(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
dumpFcb(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
dumpVcb(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
dumpVdo(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
dumpSiteInfo(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
dumpSpcInfo(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
dumpIpInfo(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
DumpDfsPrefixTableEntry(
|
|
ULONG_PTR dwAddress,
|
|
VOID (*DispFunc)(ULONG_PTR dwAddress)
|
|
);
|
|
|
|
VOID
|
|
DumpUnicodePrefixTable(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
DumpUnicodePrefixTableEntry(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
DoIndent(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
MyDumpPktEntry(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
MyDumpLocalVolEntry(
|
|
ULONG_PTR dwAddress
|
|
);
|
|
|
|
VOID
|
|
MyDumpServices(
|
|
ULONG_PTR dwAddress,
|
|
ULONG ServiceCount
|
|
);
|
|
|
|
/*
|
|
* globals
|
|
*/
|
|
INT Indent = 0;
|
|
|
|
/*
|
|
* dfsdata : Routine to dump the global dfs data structure
|
|
*
|
|
*/
|
|
|
|
BOOL
|
|
dfsdata(
|
|
ULONG_PTR dwCurrentPC,
|
|
PWINDBG_EXTENSION_APIS lpExtensionApis,
|
|
LPSTR lpArgumentString
|
|
)
|
|
{
|
|
ULONG_PTR dwAddress;
|
|
|
|
dwAddress = (GetExpression)("dfs!DfsData");
|
|
|
|
if (dwAddress) {
|
|
DFS_DATA DfsData;
|
|
|
|
if (wGetData( dwAddress, &DfsData, sizeof(DfsData) )) {
|
|
PrintStructFields( dwAddress, &DfsData, DfsDataFields);
|
|
} else {
|
|
PRINTF( "Unable to read DfsData @ %08lx\n", dwAddress );
|
|
}
|
|
} else {
|
|
PRINTF( NO_SYMBOLS_MESSAGE );
|
|
}
|
|
|
|
return( TRUE );
|
|
|
|
}
|
|
|
|
/*
|
|
* pkt : Routine to dump the Dfs PKT data structure
|
|
*
|
|
*/
|
|
|
|
BOOL
|
|
pkt(
|
|
ULONG_PTR dwCurrentPC,
|
|
PWINDBG_EXTENSION_APIS lpExtensionApis,
|
|
LPSTR lpArgumentString
|
|
)
|
|
{
|
|
ULONG_PTR dwAddress;
|
|
|
|
//
|
|
// Figure out the address of the Pkt. This is an offset within
|
|
// dfs!DfsData.
|
|
//
|
|
|
|
dwAddress = (GetExpression)("dfs!DfsData");
|
|
|
|
if (dwAddress) {
|
|
DFS_PKT pkt;
|
|
|
|
dwAddress += FIELD_OFFSET(DFS_DATA, Pkt);
|
|
|
|
if (wGetData(dwAddress,&pkt,sizeof(pkt))) {
|
|
PrintStructFields( dwAddress, &pkt, DfsPktFields );
|
|
dwAddress += FIELD_OFFSET(DFS_PKT, EntryList);
|
|
dumplist(
|
|
dwAddress,
|
|
FIELD_OFFSET(DFS_PKT_ENTRY,Link),
|
|
dumpPktEntry);
|
|
}
|
|
} else {
|
|
PRINTF( NO_SYMBOLS_MESSAGE );
|
|
}
|
|
|
|
return( TRUE );
|
|
|
|
}
|
|
|
|
/*
|
|
* dumpPktEntry : Routine suitable as argument for dumplist; used to dump
|
|
* list of pkt entries.
|
|
*
|
|
*/
|
|
|
|
VOID
|
|
dumpPktEntry(
|
|
ULONG_PTR dwAddress
|
|
)
|
|
{
|
|
DFS_PKT_ENTRY pktEntry;
|
|
|
|
if (wGetData(dwAddress, &pktEntry, sizeof(DFS_PKT_ENTRY))) {
|
|
|
|
PRINTF( "\n--- Pkt Entry @ %08lx\n", dwAddress);
|
|
|
|
wPrintStringW("Prefix : ", &pktEntry.Id.Prefix, TRUE);
|
|
wPrintStringW("ShortPrefix : ", &pktEntry.Id.ShortPrefix, TRUE);
|
|
|
|
//
|
|
// Print the local service, if any
|
|
//
|
|
if (pktEntry.LocalService != NULL) {
|
|
DFS_SERVICE Svc;
|
|
|
|
PRINTF( " Local Svc @%08lx : ",pktEntry.LocalService);
|
|
if (wGetData( (ULONG_PTR)pktEntry.LocalService, &Svc, sizeof(Svc))) {
|
|
wPrintStringW("Storage Id = ", &Svc.Address, TRUE);
|
|
} else {
|
|
PRINTF( "Storage Id = ?\n");
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now, print the service list
|
|
//
|
|
if (pktEntry.Info.ServiceCount != 0) {
|
|
ULONG i;
|
|
|
|
for (i = 0; i < pktEntry.Info.ServiceCount; i++) {
|
|
DFS_SERVICE Svc;
|
|
ULONG_PTR dwServiceAddress;
|
|
if (CheckControlC())
|
|
return;
|
|
dwServiceAddress =
|
|
((ULONG_PTR)pktEntry.Info.ServiceList) +
|
|
i * sizeof(DFS_SERVICE);
|
|
PRINTF( " Service %d @%08lx : ",i, dwServiceAddress);
|
|
if (wGetData(dwServiceAddress, &Svc, sizeof(Svc))) {
|
|
wPrintStringW( "Address =", &Svc.Address, TRUE );
|
|
} else {
|
|
PRINTF( "Address = ?\n");
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
PRINTF( "Unable to get Pkt Entry @%08lx\n", dwAddress);
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
PktEntryDump(ULONG_PTR dwAddress)
|
|
{
|
|
DFS_PKT_ENTRY pktEntry;
|
|
|
|
if (wGetData(dwAddress, &pktEntry, sizeof(DFS_PKT_ENTRY))) {
|
|
|
|
PRINTF( "\n--- Pkt Entry @ %08lx\n", dwAddress);
|
|
|
|
wPrintStringW("Prefix : ", &pktEntry.Id.Prefix, TRUE);
|
|
wPrintStringW("ShortPrefix : ", &pktEntry.Id.ShortPrefix, TRUE);
|
|
|
|
//
|
|
// Print the local service, if any
|
|
//
|
|
if (pktEntry.LocalService != NULL) {
|
|
DFS_SERVICE Svc;
|
|
|
|
PRINTF( " Local Svc @%08lx : ",pktEntry.LocalService);
|
|
if (wGetData( (ULONG_PTR)pktEntry.LocalService, &Svc, sizeof(Svc))) {
|
|
wPrintStringW("Storage Id = ", &Svc.Address, TRUE);
|
|
} else {
|
|
PRINTF( "Storage Id = ?\n");
|
|
}
|
|
}
|
|
} else {
|
|
PRINTF( "Unable to get Pkt Entry @%08lx\n", dwAddress);
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* fcbtable : Routine to dump the dfs fcb hash table
|
|
*
|
|
*/
|
|
|
|
BOOL
|
|
fcbtable(
|
|
DWORD dwCurrentPC,
|
|
PWINDBG_EXTENSION_APIS lpExtensionApis,
|
|
LPSTR lpArgumentString
|
|
)
|
|
{
|
|
DWORD_PTR dwAddress;
|
|
|
|
//
|
|
// Figure out the address of the Pkt. This is an offset withing
|
|
// Dfs!DfsData.
|
|
//
|
|
|
|
dwAddress = (GetExpression)("Dfs!DfsData");
|
|
|
|
if (dwAddress) {
|
|
DFS_DATA DfsData;
|
|
|
|
if (wGetData(dwAddress, &DfsData, sizeof(DFS_DATA))) {
|
|
FCB_HASH_TABLE FcbTable;
|
|
dwAddress = (DWORD_PTR) DfsData.FcbHashTable;
|
|
if (wGetData(dwAddress, &FcbTable, sizeof(FCB_HASH_TABLE))) {
|
|
ULONG i, cBuckets;
|
|
DWORD_PTR dwListHeadAddress;
|
|
cBuckets = FcbTable.HashMask + 1;
|
|
dwListHeadAddress =
|
|
dwAddress + FIELD_OFFSET(FCB_HASH_TABLE, HashBuckets);
|
|
PRINTF(
|
|
"+++ Fcb Hash Table @ %p (%d Buckets) +++\n",
|
|
dwAddress, cBuckets);
|
|
for (i = 0; i < cBuckets; i++) {
|
|
if (CheckControlC())
|
|
return TRUE;
|
|
PRINTF( "--- Bucket(%d)\n", i );
|
|
dumplist(
|
|
dwListHeadAddress,
|
|
FIELD_OFFSET(DFS_FCB, HashChain),
|
|
dumpFcb);
|
|
dwListHeadAddress += sizeof(LIST_ENTRY);
|
|
}
|
|
PRINTF("--- Fcb Hash Table @ %08lx ---\n", dwAddress);
|
|
|
|
} else {
|
|
PRINTF( "Unable to read FcbTable @%08lx\n", dwAddress );
|
|
}
|
|
} else {
|
|
PRINTF( "Unable to read DfsData @%08lx\n", dwAddress);
|
|
}
|
|
} else {
|
|
PRINTF( NO_SYMBOLS_MESSAGE );
|
|
}
|
|
return( TRUE );
|
|
}
|
|
|
|
/*
|
|
* dumpFcb : Routine suitable as argument to dumplist; used to dump list of
|
|
* Fcbs
|
|
*
|
|
*/
|
|
|
|
VOID
|
|
dumpFcb(
|
|
DWORD_PTR dwAddress
|
|
)
|
|
{
|
|
DFS_FCB fcb;
|
|
|
|
if (wGetData( dwAddress, &fcb, sizeof(fcb))) {
|
|
PRINTF("\nFcb @ %08lx\n", dwAddress);
|
|
PrintStructFields( dwAddress, &fcb, FcbFields );
|
|
} else {
|
|
PRINTF("\nUnable to read Fcb @ %08lx\n", dwAddress);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* vdolist : Routine to dump out all the Dfs Volume Device Objects (ie, the
|
|
* attached device objects)
|
|
*
|
|
*/
|
|
|
|
BOOL
|
|
vdolist(
|
|
ULONG_PTR dwCurrentPC,
|
|
PWINDBG_EXTENSION_APIS lpExtensionApis,
|
|
LPSTR lpArgumentString
|
|
)
|
|
{
|
|
ULONG_PTR dwAddress;
|
|
|
|
//
|
|
// Figure out the address of the Pkt. This is an offset within
|
|
// dfs!DfsData.
|
|
//
|
|
|
|
dwAddress = (GetExpression)("dfs!DfsData");
|
|
|
|
if (dwAddress) {
|
|
dwAddress += FIELD_OFFSET(DFS_DATA, AVdoQueue);
|
|
dumplist(
|
|
dwAddress,
|
|
FIELD_OFFSET(DFS_VOLUME_OBJECT,VdoLinks),
|
|
dumpVdo);
|
|
} else {
|
|
PRINTF( NO_SYMBOLS_MESSAGE );
|
|
}
|
|
return(TRUE);
|
|
|
|
}
|
|
|
|
BOOL
|
|
dumpspecialtable(
|
|
ULONG_PTR dwAddress)
|
|
{
|
|
ULONG i;
|
|
SPECIAL_HASH_TABLE HashTable;
|
|
|
|
if (wGetData(dwAddress,&HashTable,sizeof(SPECIAL_HASH_TABLE))) {
|
|
ULONG nBuckets = HashTable.HashMask+1;
|
|
PRINTF( "NodeByteCode: 0x%x\n", HashTable.NodeTypeCode);
|
|
PRINTF( "NodeByteSize: 0x%x\n", HashTable.NodeByteSize);
|
|
PRINTF( "Timeout: 0x%x\n", HashTable.SpcTimeout);
|
|
PRINTF( "HashMask: 0x%x\n", HashTable.HashMask);
|
|
|
|
if (HashTable.NodeTypeCode != DFS_NTC_SPECIAL_HASH) {
|
|
PRINTF( "NodeTypeCode != DFS_NTC_SPECIAL_HASH\n");
|
|
}
|
|
if ((HashTable.HashMask & (HashTable.HashMask+1)) != 0) {
|
|
PRINTF( "HashMask not a power of 2!\n");
|
|
return (TRUE);
|
|
}
|
|
dwAddress += FIELD_OFFSET(SPECIAL_HASH_TABLE, HashBuckets[0]);
|
|
for (i = 0; i < nBuckets; i++) {
|
|
LIST_ENTRY ListEntry;
|
|
|
|
if (wGetData(dwAddress,&ListEntry,sizeof(LIST_ENTRY))) {
|
|
if (ListEntry.Flink) {
|
|
dumplist(
|
|
dwAddress,
|
|
FIELD_OFFSET(DFS_SPECIAL_INFO,HashChain),
|
|
dumpSpcInfo);
|
|
}
|
|
} else {
|
|
PRINTF("Couldn't get Bucket[%d]\n", i);
|
|
return (TRUE);
|
|
}
|
|
dwAddress += sizeof(LIST_ENTRY);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* specialtable : Routine to dump out the special table
|
|
*
|
|
*/
|
|
|
|
BOOL
|
|
specialtable(
|
|
ULONG_PTR dwCurrentPC,
|
|
PWINDBG_EXTENSION_APIS lpExtensionApis,
|
|
LPSTR lpArgumentString)
|
|
{
|
|
ULONG i;
|
|
ULONG_PTR dwAddress;
|
|
|
|
//
|
|
// Figure out the address of the Pkt. This is an offset within
|
|
// dfs!DfsData.
|
|
//
|
|
|
|
dwAddress = (GetExpression)("dfs!DfsData");
|
|
|
|
if (dwAddress) {
|
|
|
|
dwAddress += FIELD_OFFSET(DFS_DATA, SpcHashTable);
|
|
if (!wGetData(dwAddress,&dwAddress,sizeof(dwAddress))) {
|
|
PRINTF("Couldn't get address of SpcHashTable\n");
|
|
return (TRUE);
|
|
}
|
|
PRINTF("SpcHashTable@0x%x\n", dwAddress);
|
|
return dumpspecialtable(dwAddress);
|
|
} else {
|
|
PRINTF( NO_SYMBOLS_MESSAGE );
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
/*
|
|
* specialtable : Routine to dump out the special table
|
|
*
|
|
*/
|
|
|
|
BOOL
|
|
ftdfstable(
|
|
ULONG_PTR dwCurrentPC,
|
|
PWINDBG_EXTENSION_APIS lpExtensionApis,
|
|
LPSTR lpArgumentString)
|
|
{
|
|
ULONG i;
|
|
ULONG_PTR dwAddress;
|
|
|
|
//
|
|
// Figure out the address of the Pkt. This is an offset within
|
|
// dfs!DfsData.
|
|
//
|
|
|
|
dwAddress = (GetExpression)("dfs!DfsData");
|
|
|
|
if (dwAddress) {
|
|
|
|
dwAddress += FIELD_OFFSET(DFS_DATA, FtDfsHashTable);
|
|
if (!wGetData(dwAddress,&dwAddress,sizeof(dwAddress))) {
|
|
PRINTF("Couldn't get address of FtDfsHashTable\n");
|
|
return (TRUE);
|
|
}
|
|
PRINTF("FtDfsHashTable@0x%x\n", dwAddress);
|
|
return dumpspecialtable(dwAddress);
|
|
} else {
|
|
PRINTF( NO_SYMBOLS_MESSAGE );
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
/*
|
|
* sitetable : Routine to dump out the site table
|
|
*
|
|
*/
|
|
|
|
BOOL
|
|
sitetable(
|
|
ULONG_PTR dwCurrentPC,
|
|
PWINDBG_EXTENSION_APIS lpExtensionApis,
|
|
LPSTR lpArgumentString)
|
|
{
|
|
ULONG i;
|
|
ULONG_PTR dwAddress;
|
|
|
|
//
|
|
// Figure out the address of the Pkt. This is an offset within
|
|
// dfs!DfsData.
|
|
//
|
|
|
|
dwAddress = (GetExpression)("dfs!DfsData");
|
|
|
|
if (dwAddress) {
|
|
SITE_HASH_TABLE HashTable;
|
|
|
|
dwAddress += FIELD_OFFSET(DFS_DATA, SiteHashTable);
|
|
if (!wGetData(dwAddress,&dwAddress,sizeof(dwAddress))) {
|
|
PRINTF("Couldn't get address of SiteHashTable\n");
|
|
return (TRUE);
|
|
}
|
|
PRINTF("SiteHashTable@0x%x\n", dwAddress);
|
|
if (wGetData(dwAddress,&HashTable,sizeof(SITE_HASH_TABLE))) {
|
|
ULONG nBuckets = HashTable.HashMask+1;
|
|
PRINTF( "NodeByteCode: 0x%x\n", HashTable.NodeTypeCode);
|
|
PRINTF( "NodeByteSize: 0x%x\n", HashTable.NodeByteSize);
|
|
PRINTF( "HashMask: 0x%x\n", HashTable.HashMask);
|
|
|
|
if (HashTable.NodeTypeCode != DFS_NTC_SITE_HASH) {
|
|
PRINTF( "NodeTypeCode != DFS_NTC_SITE_HASH\n");
|
|
}
|
|
if ((HashTable.HashMask & (HashTable.HashMask+1)) != 0) {
|
|
PRINTF( "HashMask not a power of 2!\n");
|
|
return (TRUE);
|
|
}
|
|
dwAddress += FIELD_OFFSET(SITE_HASH_TABLE, HashBuckets[0]);
|
|
for (i = 0; i < nBuckets; i++) {
|
|
LIST_ENTRY ListEntry;
|
|
|
|
if (CheckControlC())
|
|
return TRUE;
|
|
if (wGetData(dwAddress,&ListEntry,sizeof(LIST_ENTRY))) {
|
|
if (ListEntry.Flink) {
|
|
dumplist(
|
|
dwAddress,
|
|
FIELD_OFFSET(DFS_SITE_INFO,HashChain),
|
|
dumpSiteInfo);
|
|
}
|
|
} else {
|
|
PRINTF("Couldn't get Bucket[%d]\n", i);
|
|
return (TRUE);
|
|
}
|
|
dwAddress += sizeof(LIST_ENTRY);
|
|
}
|
|
}
|
|
} else {
|
|
PRINTF( NO_SYMBOLS_MESSAGE );
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
* iptable : Routine to dump out the ip table
|
|
*
|
|
*/
|
|
|
|
BOOL
|
|
iptable(
|
|
ULONG_PTR dwCurrentPC,
|
|
PWINDBG_EXTENSION_APIS lpExtensionApis,
|
|
LPSTR lpArgumentString)
|
|
{
|
|
ULONG i;
|
|
ULONG_PTR dwAddress;
|
|
|
|
//
|
|
// Figure out the address of the Pkt. This is an offset within
|
|
// dfs!DfsData.
|
|
//
|
|
|
|
dwAddress = (GetExpression)("dfs!DfsData");
|
|
|
|
if (dwAddress) {
|
|
IP_HASH_TABLE HashTable;
|
|
|
|
dwAddress += FIELD_OFFSET(DFS_DATA, IpHashTable);
|
|
if (!wGetData(dwAddress,&dwAddress,sizeof(dwAddress))) {
|
|
PRINTF("Couldn't get address of IpHashTable\n");
|
|
return (TRUE);
|
|
}
|
|
PRINTF("IpHashTable@0x%x\n", dwAddress);
|
|
if (wGetData(dwAddress,&HashTable,sizeof(IP_HASH_TABLE))) {
|
|
ULONG nBuckets = HashTable.HashMask+1;
|
|
PRINTF( "NodeByteCode: 0x%x\n", HashTable.NodeTypeCode);
|
|
PRINTF( "NodeByteSize: 0x%x\n", HashTable.NodeByteSize);
|
|
PRINTF( "MaxEntries: 0x%x\n", HashTable.MaxEntries);
|
|
PRINTF( "EntryCount: 0x%x\n", HashTable.EntryCount);
|
|
PRINTF( "HashMask: 0x%x\n", HashTable.HashMask);
|
|
|
|
if (HashTable.NodeTypeCode != DFS_NTC_IP_HASH) {
|
|
PRINTF( "NodeTypeCode != DFS_NTC_IP_HASH\n");
|
|
}
|
|
if ((HashTable.HashMask & (HashTable.HashMask+1)) != 0) {
|
|
PRINTF( "HashMask not a power of 2!\n");
|
|
return (TRUE);
|
|
}
|
|
dwAddress += FIELD_OFFSET(IP_HASH_TABLE, HashBuckets[0]);
|
|
for (i = 0; i < nBuckets; i++) {
|
|
LIST_ENTRY ListEntry;
|
|
|
|
if (CheckControlC())
|
|
return TRUE;
|
|
if (wGetData(dwAddress,&ListEntry,sizeof(LIST_ENTRY))) {
|
|
if (ListEntry.Flink) {
|
|
dumplist(
|
|
dwAddress,
|
|
FIELD_OFFSET(DFS_IP_INFO,HashChain),
|
|
dumpIpInfo);
|
|
}
|
|
} else {
|
|
PRINTF("Couldn't get Bucket[%d]\n", i);
|
|
return (TRUE);
|
|
}
|
|
dwAddress += sizeof(LIST_ENTRY);
|
|
}
|
|
}
|
|
} else {
|
|
PRINTF( NO_SYMBOLS_MESSAGE );
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
/*
|
|
* Dumpdfs : recursively dumps a DFS_PREFIX_TABLE
|
|
*
|
|
*/
|
|
|
|
BOOL
|
|
dumpdfs(
|
|
ULONG_PTR dwCurrentPC,
|
|
PWINDBG_EXTENSION_APIS lpExtensionApis,
|
|
LPSTR lpArgumentString
|
|
)
|
|
{
|
|
PDFS_DATA pDfsData;
|
|
PDFS_PKT pPkt;
|
|
ULONG_PTR dwAddress;
|
|
ULONG_PTR dwPrefixTable;
|
|
|
|
if( lpArgumentString && *lpArgumentString ) {
|
|
|
|
BYTE DataBuffer[sizeof(DFS_DATA)];
|
|
pDfsData = (PDFS_DATA) DataBuffer;
|
|
|
|
dwAddress = (GetExpression)( lpArgumentString );
|
|
|
|
if (wGetData(dwAddress,pDfsData,sizeof(DFS_DATA))) {
|
|
|
|
if (pDfsData->NodeTypeCode != DSFS_NTC_DATA_HEADER) {
|
|
PRINTF( "Bad NodeTypeCode - not a DfsData struct\n");
|
|
return (FALSE);
|
|
}
|
|
PRINTF( "--DFSDATA@0x%x--\n", dwAddress);
|
|
PRINTF( "DfsData->NodeTypeCode: 0x%x\n", pDfsData->NodeTypeCode);
|
|
PRINTF( "DfsData->Pkt@0x%x\n", FIELD_OFFSET(DFS_DATA, Pkt) + dwAddress);
|
|
PRINTF( "DfsData->Pkt.NodeTypeCode: 0x%x\n", pDfsData->Pkt.NodeTypeCode);
|
|
|
|
// LocalVolTable
|
|
dwPrefixTable = dwAddress + FIELD_OFFSET(DFS_DATA, Pkt.LocalVolTable.RootEntry);
|
|
DumpDfsPrefixTableEntry(dwPrefixTable, MyDumpLocalVolEntry);
|
|
|
|
// PrefixTable
|
|
dwPrefixTable = dwAddress + FIELD_OFFSET(DFS_DATA, Pkt.PrefixTable.RootEntry);
|
|
DumpDfsPrefixTableEntry(dwPrefixTable, MyDumpPktEntry);
|
|
|
|
// PrefixTable
|
|
dwPrefixTable = dwAddress + FIELD_OFFSET(DFS_DATA, Pkt.ShortPrefixTable.RootEntry);
|
|
DumpDfsPrefixTableEntry(dwPrefixTable, MyDumpPktEntry);
|
|
|
|
} else {
|
|
PRINTF( "Error reading Memory @ %lx\n",dwAddress);
|
|
}
|
|
} else {
|
|
//
|
|
// The command is of the form
|
|
// dumpdfs addr
|
|
//
|
|
// The user didn't give us an address.
|
|
//
|
|
|
|
PRINTF(
|
|
"!dfskd.dumpDfsPrefixTable address\n"
|
|
);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* DumpUnicodePrefixTable : Dump a UNICODE_PREFIX_TABLE
|
|
*
|
|
*/
|
|
VOID
|
|
DumpUnicodePrefixTable(ULONG_PTR dwAddress)
|
|
{
|
|
PUNICODE_PREFIX_TABLE pUnicodePrefixTable;
|
|
BYTE DataBuffer[sizeof(UNICODE_PREFIX_TABLE)];
|
|
|
|
pUnicodePrefixTable = (PUNICODE_PREFIX_TABLE) DataBuffer;
|
|
if (wGetData(dwAddress,pUnicodePrefixTable,sizeof(UNICODE_PREFIX_TABLE))) {
|
|
IPRINTF(0, "UNICODE_PREFIX_TABLE @ 0x%lx:\n", dwAddress);
|
|
IPRINTF(0, "NodeTypeCode : 0x%x\n", pUnicodePrefixTable->NodeTypeCode);
|
|
IPRINTF(0, "NextPrefixTree : 0x%lx\n", pUnicodePrefixTable->NextPrefixTree);
|
|
IPRINTF(0, "LastNextEntry : 0x%lx\n", pUnicodePrefixTable->LastNextEntry);
|
|
DumpUnicodePrefixTableEntry((ULONG_PTR)pUnicodePrefixTable->NextPrefixTree);
|
|
} else {
|
|
PRINTF( "Error reading Memory @ %lx\n",dwAddress);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* DumpUnicodePrefixTableEntry : UNICODE_PREFIX_TABLE_ENTRY
|
|
*
|
|
*/
|
|
VOID
|
|
DumpUnicodePrefixTableEntry(ULONG_PTR dwAddress)
|
|
{
|
|
PUNICODE_PREFIX_TABLE_ENTRY pUnicodePrefixTableEntry;
|
|
BYTE DataBuffer[sizeof(UNICODE_PREFIX_TABLE_ENTRY)];
|
|
|
|
pUnicodePrefixTableEntry = (PUNICODE_PREFIX_TABLE_ENTRY) DataBuffer;
|
|
if (wGetData(dwAddress,pUnicodePrefixTableEntry,sizeof(UNICODE_PREFIX_TABLE_ENTRY))) {
|
|
// Get and print PathSegment
|
|
if (pUnicodePrefixTableEntry->Prefix->Buffer) {
|
|
IPRINTF( "UNICODE_PREFIX_TABLE_ENTRY @ 0x%lx:\n", dwAddress);
|
|
IPRINTF( "NodeTypeCode : 0x%x\n", pUnicodePrefixTableEntry->NodeTypeCode);
|
|
IPRINTSTRINGW("", pUnicodePrefixTableEntry->Prefix, TRUE);
|
|
}
|
|
} else {
|
|
PRINTF( "Error reading Memory @ %lx\n",dwAddress);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* DumpDfsPrefixTableEntry : Recursively dump a DFS_PREFIX_TABLE
|
|
*
|
|
* Prints the DFS_PREFIX_TABLE_ENTRY, then calls itself to print any siblings,
|
|
* then calls itself to print children.
|
|
*
|
|
*/
|
|
|
|
VOID
|
|
DumpDfsPrefixTableEntry(ULONG_PTR dwAddress, VOID (*DumpFunc)(ULONG_PTR dwAddress))
|
|
{
|
|
PDFS_PREFIX_TABLE_ENTRY pDfsPrefixTableEntry;
|
|
BYTE DataBuffer[sizeof(DFS_PREFIX_TABLE_ENTRY)];
|
|
BOOLEAN Verbose = 0;
|
|
|
|
|
|
if (CheckControlC())
|
|
return;
|
|
pDfsPrefixTableEntry = (PDFS_PREFIX_TABLE_ENTRY) DataBuffer;
|
|
if (wGetData(dwAddress,pDfsPrefixTableEntry,sizeof(DFS_PREFIX_TABLE_ENTRY))) {
|
|
|
|
IPRINTF( "------DFS_PREFIX_TABLE_ENTRY@0x%x-----------\n", dwAddress);
|
|
IPRINTF( "pParentEntry: 0x%lx\n", pDfsPrefixTableEntry->pParentEntry);
|
|
IPRINTF( "pNextEntry: 0x%lx\n", pDfsPrefixTableEntry->pNextEntry);
|
|
IPRINTF( "pPrevEntry: 0x%lx\n", pDfsPrefixTableEntry->pPrevEntry);
|
|
IPRINTF( "pFirstChildEntry: 0x%lx\n", pDfsPrefixTableEntry->pFirstChildEntry);
|
|
IPRINTF( "pSiblingEntry: 0x%lx\n", pDfsPrefixTableEntry->pSiblingEntry);
|
|
IPRINTF( "NoOfChildren: 0x%lx\n", pDfsPrefixTableEntry->NoOfChildren);
|
|
IPRINTF( "PathSegment: %lx\n", pDfsPrefixTableEntry->PathSegment.Buffer);
|
|
IPRINTF( "pData: 0x%lx\n", pDfsPrefixTableEntry->pData);
|
|
|
|
// Get and print PathSegment
|
|
if (pDfsPrefixTableEntry->PathSegment.Buffer) {
|
|
IPRINTSTRINGW("", &pDfsPrefixTableEntry->PathSegment, FALSE);
|
|
IPRINTF( " --> 0x%x\n", pDfsPrefixTableEntry->pData);
|
|
if (pDfsPrefixTableEntry->pData) {
|
|
ULONG_PTR dwDfsPktEntry;
|
|
|
|
dwDfsPktEntry = (ULONG_PTR) pDfsPrefixTableEntry->pData;
|
|
Indent++;
|
|
DumpFunc(dwDfsPktEntry);
|
|
Indent--;
|
|
}
|
|
}
|
|
|
|
IPRINTF( "--------------------------------------------\n", dwAddress);
|
|
|
|
// recursively dump Siblings
|
|
if (pDfsPrefixTableEntry->pSiblingEntry)
|
|
DumpDfsPrefixTableEntry(
|
|
(ULONG_PTR)pDfsPrefixTableEntry->pSiblingEntry,
|
|
DumpFunc);
|
|
|
|
// then children
|
|
Indent++;
|
|
if (pDfsPrefixTableEntry->pFirstChildEntry)
|
|
DumpDfsPrefixTableEntry(
|
|
(ULONG_PTR)pDfsPrefixTableEntry->pFirstChildEntry,
|
|
DumpFunc);
|
|
Indent--;
|
|
|
|
} else {
|
|
PRINTF( "Error reading Memory @ %lx\n",dwAddress);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
MyDumpPktEntry(ULONG_PTR dwAddress)
|
|
{
|
|
PDFS_PKT_ENTRY pDfsPktEntry;
|
|
BYTE DataBuffer[sizeof(DFS_PKT_ENTRY)];
|
|
|
|
// dwAddress points to PrefixTableEntry within the DFS_PKT_ENTRY struct
|
|
dwAddress -= FIELD_OFFSET(DFS_PKT_ENTRY, PrefixTableEntry);
|
|
pDfsPktEntry = (PDFS_PKT_ENTRY) DataBuffer;
|
|
if (wGetData(dwAddress,pDfsPktEntry,sizeof(DFS_PKT_ENTRY))) {
|
|
|
|
IPRINTF( "---------DFS_PKT_ENTRY@0x%x----\n", dwAddress);
|
|
IPRINTF( "NodeTypeCode: 0x%x\n", pDfsPktEntry->NodeTypeCode);
|
|
IPRINTF( "Type: 0x%x\n", pDfsPktEntry->Type);
|
|
Indent++;
|
|
IPRINTF( "----DFS_PKT_ENTRY_ID@0x%x------\n", dwAddress + FIELD_OFFSET(DFS_PKT_ENTRY, Id));
|
|
IPRINTSTRINGW("Prefix: ", &pDfsPktEntry->Id.Prefix, TRUE);
|
|
IPRINTSTRINGW("ShortPrefix:", &pDfsPktEntry->Id.Prefix, TRUE);
|
|
IPRINTF( "-------------------------------\n");
|
|
|
|
IPRINTF( "---DFS_PKT_ENTRY_INFO@0x%x-----\n", dwAddress + FIELD_OFFSET(DFS_PKT_ENTRY, Info));
|
|
IPRINTF( "Timeout\n", pDfsPktEntry->Info.Timeout);
|
|
IPRINTF( "ServiceList (%d services)\n", pDfsPktEntry->Info.ServiceCount);
|
|
Indent++;
|
|
MyDumpServices((ULONG_PTR)pDfsPktEntry->Info.ServiceList, pDfsPktEntry->Info.ServiceCount);
|
|
Indent--;
|
|
IPRINTF( "-------------------------------\n");
|
|
IPRINTF( "ActiveService:\n");
|
|
Indent++;
|
|
MyDumpServices((ULONG_PTR)pDfsPktEntry->ActiveService, 1);
|
|
Indent--;
|
|
IPRINTF( "LocalService:\n");
|
|
Indent++;
|
|
MyDumpServices((ULONG_PTR)pDfsPktEntry->LocalService, 1);
|
|
Indent--;
|
|
IPRINTF( "-------------------------------\n");
|
|
Indent--;
|
|
IPRINTF( "-------------------------------\n");
|
|
}
|
|
}
|
|
|
|
VOID
|
|
MyDumpServices(ULONG_PTR dwAddress, ULONG ServiceCount)
|
|
{
|
|
PDFS_SERVICE pDfsService;
|
|
BYTE DataBuffer[sizeof(DFS_SERVICE) * 32];
|
|
ULONG i;
|
|
|
|
pDfsService = (PDFS_SERVICE) DataBuffer;
|
|
if (wGetData(dwAddress,pDfsService,sizeof(DFS_SERVICE) * ServiceCount)) {
|
|
|
|
for (i = 0; i < ServiceCount; i++) {
|
|
|
|
if (CheckControlC())
|
|
return;
|
|
IPRINTF( "----DFS_SERVICE@0x%x---\n", dwAddress);
|
|
IPRINTSTRINGW("Service:", &pDfsService[i].Address, TRUE);
|
|
IPRINTF( "-----------------------\n");
|
|
dwAddress += sizeof(DFS_SERVICE);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID
|
|
MyDumpLocalVolEntry(ULONG_PTR dwPrefixTableEntry)
|
|
{
|
|
PDFS_LOCAL_VOL_ENTRY pDfsLocalVolEntry;
|
|
BYTE DataBuffer[sizeof(DFS_LOCAL_VOL_ENTRY)];
|
|
ULONG_PTR dwAddress;
|
|
|
|
dwAddress = dwPrefixTableEntry - FIELD_OFFSET(DFS_LOCAL_VOL_ENTRY, PrefixTableEntry);
|
|
pDfsLocalVolEntry = (PDFS_LOCAL_VOL_ENTRY) DataBuffer;
|
|
if (wGetData(dwAddress,pDfsLocalVolEntry,sizeof(DFS_LOCAL_VOL_ENTRY))) {
|
|
IPRINTF( "---------DFS_LOCAL_VOL_ENTRY@0x%x-----\n", dwAddress);
|
|
IPRINTSTRINGW("LocalPath:", &pDfsLocalVolEntry->LocalPath, TRUE);
|
|
IPRINTSTRINGW("ShareName:", &pDfsLocalVolEntry->ShareName, TRUE);
|
|
Indent++;
|
|
MyDumpPktEntry(
|
|
(ULONG_PTR) pDfsLocalVolEntry->PktEntry +
|
|
FIELD_OFFSET(DFS_PKT_ENTRY, PrefixTableEntry)
|
|
);
|
|
Indent--;
|
|
IPRINTF( "--------------------------------------\n", dwAddress);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* dumpVdo : Routine suitable as argument to dumplist; used to dump list of
|
|
* Vdos
|
|
*/
|
|
|
|
void dumpVdo(
|
|
ULONG_PTR dwAddress
|
|
)
|
|
{
|
|
DFS_VOLUME_OBJECT dfsVdo;
|
|
|
|
if (wGetData( dwAddress, &dfsVdo, sizeof(dfsVdo) )) {
|
|
PRINTF( "\nVDO @ %08lx\n", dwAddress);
|
|
PrintStructFields( dwAddress, &dfsVdo, DfsVolumeObjectFields );
|
|
} else {
|
|
PRINTF( "\nUnable to read VDO @%08lx\n", dwAddress);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* dumpSpcInfo : Routine suitable as argument to dumplist; used to dump list of
|
|
* DFS_SPECIAL_INFO's
|
|
*/
|
|
|
|
void dumpSpcInfo(
|
|
ULONG_PTR dwAddress
|
|
)
|
|
{
|
|
ULONG_PTR dwName;
|
|
DFS_SPECIAL_INFO dfsSpcInfo;
|
|
LONG i;
|
|
UNICODE_STRING uStr;
|
|
|
|
if (wGetData( dwAddress, &dfsSpcInfo, sizeof(dfsSpcInfo) )) {
|
|
PRINTF( " DFS_SPECIAL_INFO @ %08lx\n", dwAddress);
|
|
PRINTF( "\tExpireTime: 0x%08x:0x%08x\n",
|
|
dfsSpcInfo.ExpireTime.HighPart,
|
|
dfsSpcInfo.ExpireTime.LowPart);
|
|
PRINTF( "\tFlags: 0x%08x\n", dfsSpcInfo.Flags, TRUE);
|
|
PRINTF( "\tTrustDirection: 0x%08x\n", dfsSpcInfo.TrustDirection, TRUE);
|
|
PRINTF( "\tTrustType: 0x%08x\n", dfsSpcInfo.TrustType, TRUE);
|
|
PRINTF( "\tTypeFlags: 0x%08x\n", dfsSpcInfo.TypeFlags, TRUE);
|
|
PRINTF( "\tNameCount: %d\n", dfsSpcInfo.NameCount, TRUE);
|
|
wPrintStringW("\tSpecialName:", &dfsSpcInfo.SpecialName, TRUE);
|
|
dwName = dwAddress + FIELD_OFFSET(DFS_SPECIAL_INFO, Name[0]);
|
|
for (i = 0; i < dfsSpcInfo.NameCount; i++) {
|
|
if (CheckControlC())
|
|
return;
|
|
wGetData(dwName, &uStr, sizeof(UNICODE_STRING));
|
|
wPrintStringW("\t\tName:", &uStr, TRUE);
|
|
dwName += sizeof(UNICODE_STRING);
|
|
}
|
|
} else {
|
|
PRINTF( "Unable to read DFS_SITE_INFO @%08lx\n", dwAddress);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* dumpSiteInfo : Routine suitable as argument to dumplist; used to dump list of
|
|
* DFS_SITE_INFO's
|
|
*/
|
|
|
|
void dumpSiteInfo(
|
|
ULONG_PTR dwAddress
|
|
)
|
|
{
|
|
ULONG_PTR dwSiteName;
|
|
DFS_SITE_INFO dfsSiteInfo;
|
|
ULONG i;
|
|
UNICODE_STRING uStr;
|
|
|
|
if (wGetData( dwAddress, &dfsSiteInfo, sizeof(dfsSiteInfo) )) {
|
|
PRINTF( " DFS_SITE_INFO @ %08lx\n", dwAddress);
|
|
wPrintStringW("\tServerName:", &dfsSiteInfo.ServerName, TRUE);
|
|
dwSiteName = dwAddress + FIELD_OFFSET(DFS_SITE_INFO, SiteName[0]);
|
|
for (i = 0; i < dfsSiteInfo.SiteCount; i++) {
|
|
wGetData(dwSiteName, &uStr, sizeof(UNICODE_STRING));
|
|
wPrintStringW("\t\tName:", &uStr, TRUE);
|
|
dwSiteName += sizeof(UNICODE_STRING);
|
|
}
|
|
} else {
|
|
PRINTF( "Unable to read DFS_SITE_INFO @%08lx\n", dwAddress);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* dumpIpInfo : Routine suitable as argument to dumplist; used to dump list of
|
|
* DFS_IP_INFO's
|
|
*/
|
|
|
|
void dumpIpInfo(
|
|
ULONG_PTR dwAddress
|
|
)
|
|
{
|
|
DFS_IP_INFO dfsIpInfo;
|
|
ULONG IpAddress;
|
|
|
|
if (wGetData( dwAddress, &dfsIpInfo, sizeof(dfsIpInfo) )) {
|
|
IpAddress = *((ULONG *)&dfsIpInfo.IpAddress.IpData);
|
|
PRINTF( " DFS_IP_INFO @ %08lx\n", dwAddress);
|
|
PRINTF( "\tIpAddress: %d.%d.%d.%d\n",
|
|
IpAddress & 0xff,
|
|
(IpAddress >> 8) & 0xff,
|
|
(IpAddress >> 16) & 0xff,
|
|
(IpAddress >> 24) & 0xff);
|
|
wPrintStringW("\tSiteName: ", &dfsIpInfo.SiteName, TRUE);
|
|
} else {
|
|
PRINTF( "Unable to read DFS_SITE_INFO @%08lx\n", dwAddress);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* dumplist : A general-purpose routine to dump a list of structures
|
|
*
|
|
*/
|
|
|
|
VOID
|
|
dumplist(
|
|
ULONG_PTR dwListEntryAddress,
|
|
DWORD linkOffset,
|
|
VOID (*dumpRoutine)(ULONG_PTR dwStructAddress)
|
|
)
|
|
{
|
|
LIST_ENTRY listHead, listNext;
|
|
ULONG max_list_entry = MAX_ENTRIES;
|
|
//
|
|
// Get the value in the LIST_ENTRY at dwAddress
|
|
//
|
|
|
|
PRINTF( "Dumping list @ %08lx\n", dwListEntryAddress );
|
|
|
|
if (wGetData(dwListEntryAddress, &listHead, sizeof(LIST_ENTRY))) {
|
|
|
|
ULONG_PTR dwNextLink = (ULONG_PTR) listHead.Flink;
|
|
ULONG_PTR dwNextdupLink = (ULONG_PTR) listHead.Flink;
|
|
ULONG loop_count = 0;
|
|
|
|
if (dwNextLink == 0) {
|
|
PRINTF( "Uninitialized list!\n" );
|
|
} else if (dwNextLink == dwListEntryAddress) {
|
|
PRINTF( "Empty list!\n" );
|
|
} else {
|
|
while( dwNextLink != dwListEntryAddress) {
|
|
ULONG_PTR dwStructAddress;
|
|
|
|
if (CheckControlC())
|
|
return;
|
|
|
|
dwStructAddress = dwNextLink - linkOffset;
|
|
|
|
dumpRoutine(dwStructAddress);
|
|
|
|
if (wGetData( dwNextLink, &listNext, sizeof(LIST_ENTRY))) {
|
|
dwNextLink = (ULONG_PTR) listNext.Flink;
|
|
} else {
|
|
PRINTF( "Unable to get next item @%08lx\n", dwNextLink );
|
|
break;
|
|
}
|
|
if (++loop_count > max_list_entry) {
|
|
PRINTF( "Dumped maximum %d entries... aborting\n", loop_count);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
PRINTF( "Unable to read list head @ %08lx\n", dwListEntryAddress);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
DoIndent(VOID)
|
|
{
|
|
INT i;
|
|
|
|
for (i = 0; i < 2 * Indent; i++)
|
|
PRINTF(" ");
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
PrintStructFields( ULONG_PTR dwAddress, VOID *ptr, FIELD_DESCRIPTOR *pFieldDescriptors )
|
|
{
|
|
int i;
|
|
WCHAR wszBuffer[80];
|
|
|
|
// Display the fields in the struct.
|
|
for( i=0; pFieldDescriptors->Name; i++, pFieldDescriptors++ ) {
|
|
|
|
// Indentation to begin the struct display.
|
|
PRINTF( " " );
|
|
|
|
if( strlen( pFieldDescriptors->Name ) > FIELD_NAME_LENGTH ) {
|
|
PRINTF( "%-17s...%s ", pFieldDescriptors->Name, pFieldDescriptors->Name+strlen(pFieldDescriptors->Name)-10 );
|
|
} else {
|
|
PRINTF( "%-30s ", pFieldDescriptors->Name );
|
|
}
|
|
|
|
switch( pFieldDescriptors->FieldType ) {
|
|
case FieldTypeByte:
|
|
case FieldTypeChar:
|
|
PRINTF( "%-16d%s",
|
|
*(BYTE *)(((char *)ptr) + pFieldDescriptors->Offset ),
|
|
NewLineForFields(i) );
|
|
break;
|
|
case FieldTypeBoolean:
|
|
PRINTF( "%-16s%s",
|
|
*(BOOLEAN *)(((char *)ptr) + pFieldDescriptors->Offset ) ? "TRUE" : "FALSE",
|
|
NewLineForFields(i));
|
|
break;
|
|
case FieldTypeBool:
|
|
PRINTF( "%-16s%s",
|
|
*(BOOLEAN *)(((char *)ptr) + pFieldDescriptors->Offset ) ? "TRUE" : "FALSE",
|
|
NewLineForFields(i));
|
|
break;
|
|
case FieldTypePointer:
|
|
PRINTF( "%-16X%s",
|
|
*(ULONG *)(((char *)ptr) + pFieldDescriptors->Offset ),
|
|
NewLineForFields(i) );
|
|
break;
|
|
case FieldTypeULong:
|
|
case FieldTypeLong:
|
|
PRINTF( "%-16d%s",
|
|
*(ULONG *)(((char *)ptr) + pFieldDescriptors->Offset ),
|
|
NewLineForFields(i) );
|
|
break;
|
|
case FieldTypeShort:
|
|
PRINTF( "%-16X%s",
|
|
*(SHORT *)(((char *)ptr) + pFieldDescriptors->Offset ),
|
|
NewLineForFields(i) );
|
|
break;
|
|
case FieldTypeUShort:
|
|
PRINTF( "%-16X%s",
|
|
*(USHORT *)(((char *)ptr) + pFieldDescriptors->Offset ),
|
|
NewLineForFields(i) );
|
|
break;
|
|
case FieldTypeGuid:
|
|
PrintGuid( (GUID *)(((char *)ptr) + pFieldDescriptors->Offset) );
|
|
PRINTF( NewLine );
|
|
break;
|
|
case FieldTypePWStr:
|
|
if (wGetString( (ULONG_PTR)(((char *)ptr) + pFieldDescriptors->Offset), (char *)wszBuffer )) {
|
|
PRINTF( "%ws", wszBuffer );
|
|
} else {
|
|
PRINTF( "Unable to get string at %08lx", (ULONG_PTR)(((char *)ptr) + pFieldDescriptors->Offset));
|
|
}
|
|
PRINTF( NewLine );
|
|
break;
|
|
case FieldTypeUnicodeString:
|
|
wPrintStringW( NULL, (UNICODE_STRING *)(((char *)ptr) + pFieldDescriptors->Offset ), 0 );
|
|
PRINTF( NewLine );
|
|
break;
|
|
case FieldTypeAnsiString:
|
|
wPrintStringA( NULL, (ANSI_STRING *)(((char *)ptr) + pFieldDescriptors->Offset ), 0 );
|
|
PRINTF( NewLine );
|
|
break;
|
|
case FieldTypeSymbol:
|
|
{
|
|
UCHAR SymbolName[ 200 ];
|
|
ULONG Displacement;
|
|
PVOID sym = (PVOID)(*(ULONG_PTR *)(((char *)ptr) + pFieldDescriptors->Offset ));
|
|
|
|
GetSymbol(sym, SymbolName, (ULONG_PTR *)&Displacement );
|
|
PRINTF( "%-16s%s",
|
|
SymbolName,
|
|
NewLineForFields(i) );
|
|
}
|
|
break;
|
|
case FieldTypeEnum:
|
|
{
|
|
ULONG EnumValue;
|
|
ENUM_VALUE_DESCRIPTOR *pEnumValueDescr;
|
|
// Get the associated numerical value.
|
|
|
|
EnumValue = *((ULONG *)((BYTE *)ptr + pFieldDescriptors->Offset));
|
|
|
|
if ((pEnumValueDescr = pFieldDescriptors->AuxillaryInfo.pEnumValueDescriptor)
|
|
!= NULL) {
|
|
//
|
|
// An auxilary textual description of the value is
|
|
// available. Display it instead of the numerical value.
|
|
//
|
|
|
|
LPSTR pEnumName = NULL;
|
|
|
|
while (pEnumValueDescr->EnumName != NULL) {
|
|
if (EnumValue == pEnumValueDescr->EnumValue) {
|
|
pEnumName = pEnumValueDescr->EnumName;
|
|
break;
|
|
}
|
|
pEnumValueDescr++;
|
|
}
|
|
|
|
if (pEnumName != NULL) {
|
|
PRINTF( "%-16s ", pEnumName );
|
|
} else {
|
|
PRINTF( "%-4d (%-10s) ", EnumValue,"Unknown!");
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// No auxilary information is associated with the ehumerated type
|
|
// print the numerical value.
|
|
//
|
|
PRINTF( "%-16d",EnumValue);
|
|
}
|
|
PRINTF( NewLineForFields(i) );
|
|
}
|
|
break;
|
|
|
|
case FieldTypeByteBitMask:
|
|
case FieldTypeWordBitMask:
|
|
case FieldTypeDWordBitMask:
|
|
{
|
|
BOOL fFirstFlag;
|
|
ULONG BitMaskValue;
|
|
BIT_MASK_DESCRIPTOR *pBitMaskDescr;
|
|
|
|
BitMaskValue = *((ULONG *)((BYTE *)ptr + pFieldDescriptors->Offset));
|
|
|
|
PRINTF("%-8x ", BitMaskValue);
|
|
PRINTF( NewLineForFields(i) );
|
|
|
|
pBitMaskDescr = pFieldDescriptors->AuxillaryInfo.pBitMaskDescriptor;
|
|
fFirstFlag = TRUE;
|
|
if (BitMaskValue != 0 && pBitMaskDescr != NULL) {
|
|
while (pBitMaskDescr->BitmaskName != NULL) {
|
|
if ((BitMaskValue & pBitMaskDescr->BitmaskValue) != 0) {
|
|
if (fFirstFlag) {
|
|
fFirstFlag = FALSE;
|
|
PRINTF(" ( %-s", pBitMaskDescr->BitmaskName);
|
|
} else {
|
|
PRINTF( " |\n" );
|
|
PRINTF(" %-s", pBitMaskDescr->BitmaskName);
|
|
|
|
}
|
|
}
|
|
pBitMaskDescr++;
|
|
}
|
|
PRINTF(" )");
|
|
PRINTF( NewLineForFields(i) );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FieldTypeStruct:
|
|
PRINTF( "@%-15X%s",
|
|
(dwAddress + pFieldDescriptors->Offset ),
|
|
NewLineForFields(i) );
|
|
break;
|
|
case FieldTypeLargeInteger:
|
|
wPrintLargeInt( (LARGE_INTEGER *)(((char *)ptr) + pFieldDescriptors->Offset) );
|
|
PRINTF( NewLine );
|
|
break;
|
|
case FieldTypeFileTime:
|
|
default:
|
|
dprintf( "Unrecognized field type %c for %s\n", pFieldDescriptors->FieldType, pFieldDescriptors->Name );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#define NAME_DELIMITER '@'
|
|
#define INVALID_INDEX 0xffffffff
|
|
#define MIN(x,y) ((x) < (y) ? (x) : (y))
|
|
|
|
ULONG SearchStructs(LPSTR lpArgument)
|
|
{
|
|
ULONG i = 0;
|
|
STRUCT_DESCRIPTOR *pStructs = Structs;
|
|
ULONG NameIndex = INVALID_INDEX;
|
|
ULONG ArgumentLength = strlen(lpArgument);
|
|
BOOLEAN fAmbiguous = FALSE;
|
|
|
|
|
|
while ((pStructs->StructName != 0)) {
|
|
ULONG StructLength;
|
|
StructLength = strlen(pStructs->StructName);
|
|
if (StructLength >= ArgumentLength) {
|
|
int Result = _strnicmp(
|
|
lpArgument,
|
|
pStructs->StructName,
|
|
ArgumentLength);
|
|
|
|
if (Result == 0) {
|
|
if (StructLength == ArgumentLength) {
|
|
// Exact match. They must mean this struct!
|
|
fAmbiguous = FALSE;
|
|
NameIndex = i;
|
|
break;
|
|
} else if (NameIndex != INVALID_INDEX) {
|
|
// We have encountered duplicate matches. Print out the
|
|
// matching strings and let the user disambiguate.
|
|
fAmbiguous = TRUE;
|
|
break;
|
|
} else {
|
|
NameIndex = i;
|
|
}
|
|
}
|
|
}
|
|
pStructs++;i++;
|
|
}
|
|
|
|
if (fAmbiguous) {
|
|
PRINTF("Ambigous Name Specification -- The following structs match\n");
|
|
PRINTF("%s\n",Structs[NameIndex].StructName);
|
|
PRINTF("%s\n",Structs[i].StructName);
|
|
while (pStructs->StructName != 0) {
|
|
if (_strnicmp(lpArgument,
|
|
pStructs->StructName,
|
|
MIN(strlen(pStructs->StructName),ArgumentLength)) == 0) {
|
|
PRINTF("%s\n",pStructs->StructName);
|
|
}
|
|
pStructs++;
|
|
}
|
|
PRINTF("Dumping Information for %s\n",Structs[NameIndex].StructName);
|
|
}
|
|
|
|
return(NameIndex);
|
|
}
|
|
|
|
VOID DisplayStructs()
|
|
{
|
|
STRUCT_DESCRIPTOR *pStructs = Structs;
|
|
|
|
PRINTF("The following structs are handled .... \n");
|
|
while (pStructs->StructName != 0) {
|
|
PRINTF("\t%s\n",pStructs->StructName);
|
|
pStructs++;
|
|
}
|
|
}
|
|
|
|
#define NAME_DELIMITERS "@"
|
|
|
|
DECLARE_API( dump )
|
|
{
|
|
ULONG_PTR dwAddress;
|
|
|
|
//SETCALLBACKS();
|
|
|
|
if( args && *args ) {
|
|
// Parse the argument string to determine the structure to be displayed.
|
|
// Scan for the NAME_DELIMITER ( '@' ).
|
|
|
|
LPSTR lpName = (PSTR)args;
|
|
LPSTR lpArgs = strpbrk(args, NAME_DELIMITERS);
|
|
ULONG Index;
|
|
|
|
if (lpArgs) {
|
|
//
|
|
// The specified command is of the form
|
|
// dump <name>@<address expr.>
|
|
//
|
|
// Locate the matching struct for the given name. In the case
|
|
// of ambiguity we seek user intervention for disambiguation.
|
|
//
|
|
// We do an inplace modification of the argument string to
|
|
// facilitate matching.
|
|
//
|
|
*lpArgs = '\0';
|
|
|
|
for (;*lpName==' ';) { lpName++; } //skip leading blanks
|
|
|
|
Index = SearchStructs(lpName);
|
|
|
|
//
|
|
// Let us restore the original value back.
|
|
//
|
|
|
|
*lpArgs = NAME_DELIMITER;
|
|
|
|
if (INVALID_INDEX != Index) {
|
|
BYTE DataBuffer[512];
|
|
|
|
dwAddress = GetExpression( ++lpArgs );
|
|
if (wGetData(dwAddress,DataBuffer,Structs[Index].StructSize)) {
|
|
|
|
PRINTF(
|
|
"++++++++++++++++ %s@%lx ++++++++++++++++\n",
|
|
Structs[Index].StructName,
|
|
dwAddress);
|
|
PrintStructFields(
|
|
dwAddress,
|
|
&DataBuffer,
|
|
Structs[Index].FieldDescriptors);
|
|
PRINTF(
|
|
"---------------- %s@%lx ----------------\n",
|
|
Structs[Index].StructName,
|
|
dwAddress);
|
|
} else {
|
|
PRINTF("Error reading Memory @ %lx\n",dwAddress);
|
|
}
|
|
} else {
|
|
// No matching struct was found. Display the list of
|
|
// structs currently handled.
|
|
|
|
DisplayStructs();
|
|
}
|
|
} else {
|
|
//
|
|
// The command is of the form
|
|
// dump <name>
|
|
//
|
|
// Currently we do not handle this. In future we will map it to
|
|
// the name of a global variable and display it if required.
|
|
//
|
|
|
|
DisplayStructs();
|
|
}
|
|
} else {
|
|
//
|
|
// display the list of structs currently handled.
|
|
//
|
|
|
|
DisplayStructs();
|
|
}
|
|
|
|
return;
|
|
}
|