/*++ Copyright (c) 1998 Microsoft Corporation Module Name: aac.c - DbgExtension Structure information specific to ATMARPC.SYS Abstract: Revision History: Who When What -------- -------- ---------------------------------------------- josephj 03-30-98 Created Notes: --*/ #include "precomp.h" enum { typeid_NULL, typeid_ATMARP_GLOBALS, typeid_ATMARP_ADAPTER, typeid_ATMARP_INTERFACE, typeid_ATMARP_ATM_ENTRY, typeid_ATMARP_IP_ENTRY, typeid_ATMARP_VC }; extern TYPE_INFO *g_rgTypes[]; // // STRUCTURES CONCERNING TYPE "ATMARP_ADAPTER" // STRUCT_FIELD_INFO rgfi_ATMARP_ADAPTER[] = { #if DBG { "aaa_sig", FIELD_OFFSET(ATMARP_ADAPTER, aaa_sig), FIELD_SIZE(ATMARP_ADAPTER, aaa_sig) }, #endif { "pNextAdapter", FIELD_OFFSET(ATMARP_ADAPTER, pNextAdapter), FIELD_SIZE(ATMARP_ADAPTER, pNextAdapter) }, { "pInterfaceList", FIELD_OFFSET(ATMARP_ADAPTER, pInterfaceList), FIELD_SIZE(ATMARP_ADAPTER, pInterfaceList) }, { "InterfaceCount", FIELD_OFFSET(ATMARP_ADAPTER, InterfaceCount), FIELD_SIZE(ATMARP_ADAPTER, InterfaceCount) }, { "NdisAdapterHandle", FIELD_OFFSET(ATMARP_ADAPTER, NdisAdapterHandle), FIELD_SIZE(ATMARP_ADAPTER, NdisAdapterHandle) }, { "BindContext", FIELD_OFFSET(ATMARP_ADAPTER, BindContext), FIELD_SIZE(ATMARP_ADAPTER, BindContext) }, { "SystemSpecific1", FIELD_OFFSET(ATMARP_ADAPTER, SystemSpecific1), FIELD_SIZE(ATMARP_ADAPTER, SystemSpecific1) }, { "SystemSpecific2", FIELD_OFFSET(ATMARP_ADAPTER, SystemSpecific2), FIELD_SIZE(ATMARP_ADAPTER, SystemSpecific2) }, #if OBSOLETE { "AdapterConfigHandle", FIELD_OFFSET(ATMARP_ADAPTER, AdapterConfigHandle), FIELD_SIZE(ATMARP_ADAPTER, AdapterConfigHandle) }, #endif // OBSOLETE { "IPConfigString", FIELD_OFFSET(ATMARP_ADAPTER, IPConfigString), FIELD_SIZE(ATMARP_ADAPTER, IPConfigString) }, { "UnbindContext", FIELD_OFFSET(ATMARP_ADAPTER, UnbindContext), FIELD_SIZE(ATMARP_ADAPTER, UnbindContext) }, { "Medium", FIELD_OFFSET(ATMARP_ADAPTER, Medium), FIELD_SIZE(ATMARP_ADAPTER, Medium) }, { "Flags", FIELD_OFFSET(ATMARP_ADAPTER, Flags), FIELD_SIZE(ATMARP_ADAPTER, Flags) }, { "LineRate", FIELD_OFFSET(ATMARP_ADAPTER, LineRate), FIELD_SIZE(ATMARP_ADAPTER, LineRate) }, { "MaxPacketSize", FIELD_OFFSET(ATMARP_ADAPTER, MaxPacketSize), FIELD_SIZE(ATMARP_ADAPTER, MaxPacketSize) }, { "MacAddress", FIELD_OFFSET(ATMARP_ADAPTER, MacAddress), FIELD_SIZE(ATMARP_ADAPTER, MacAddress) }, { "DescrLength", FIELD_OFFSET(ATMARP_ADAPTER, DescrLength), FIELD_SIZE(ATMARP_ADAPTER, DescrLength) }, { "pDescrString", FIELD_OFFSET(ATMARP_ADAPTER, pDescrString), FIELD_SIZE(ATMARP_ADAPTER, pDescrString) }, { "DeviceName", FIELD_OFFSET(ATMARP_ADAPTER, DeviceName), FIELD_SIZE(ATMARP_ADAPTER, DeviceName) }, { "ConfigString", FIELD_OFFSET(ATMARP_ADAPTER, ConfigString), FIELD_SIZE(ATMARP_ADAPTER, ConfigString) }, { "Block", FIELD_OFFSET(ATMARP_ADAPTER, Block), FIELD_SIZE(ATMARP_ADAPTER, Block) }, { NULL } }; TYPE_INFO type_ATMARP_ADAPTER = { "ATMARP_ADAPTER", "a", typeid_ATMARP_ADAPTER, fTYPEINFO_ISLIST, // Flags sizeof(ATMARP_ADAPTER), rgfi_ATMARP_ADAPTER, FIELD_OFFSET(ATMARP_ADAPTER, pNextAdapter) // offset to next pointer. }; // // STRUCTURES CONCERNING TYPE "ATMARP_GLOBALS" // STRUCT_FIELD_INFO rgfi_ATMARP_GLOBALS[] = { #if DBG { "aag_sig", FIELD_OFFSET(ATMARP_GLOBALS, aag_sig), FIELD_SIZE(ATMARP_GLOBALS, aag_sig) }, #endif // DBG { "Lock", FIELD_OFFSET(ATMARP_GLOBALS, Lock), FIELD_SIZE(ATMARP_GLOBALS, Lock) }, { "ProtocolHandle", FIELD_OFFSET(ATMARP_GLOBALS, ProtocolHandle), FIELD_SIZE(ATMARP_GLOBALS, ProtocolHandle) }, { "pDriverObject", FIELD_OFFSET(ATMARP_GLOBALS, pDriverObject), FIELD_SIZE(ATMARP_GLOBALS, pDriverObject) }, { "pDeviceObject", FIELD_OFFSET(ATMARP_GLOBALS, pDeviceObject), FIELD_SIZE(ATMARP_GLOBALS, pDeviceObject) }, { "pAdapterList", FIELD_OFFSET(ATMARP_GLOBALS, pAdapterList), FIELD_SIZE(ATMARP_GLOBALS, pAdapterList) }, { "AdapterCount", FIELD_OFFSET(ATMARP_GLOBALS, AdapterCount), FIELD_SIZE(ATMARP_GLOBALS, AdapterCount) }, { "bUnloading", FIELD_OFFSET(ATMARP_GLOBALS, bUnloading), FIELD_SIZE(ATMARP_GLOBALS, bUnloading) }, #ifdef NEWARP { "ARPRegisterHandle", FIELD_OFFSET(ATMARP_GLOBALS, ARPRegisterHandle), FIELD_SIZE(ATMARP_GLOBALS, ARPRegisterHandle) }, { "pIPAddInterfaceRtn", FIELD_OFFSET(ATMARP_GLOBALS, pIPAddInterfaceRtn), FIELD_SIZE(ATMARP_GLOBALS, pIPAddInterfaceRtn) }, { "pIPDelInterfaceRtn", FIELD_OFFSET(ATMARP_GLOBALS, pIPDelInterfaceRtn), FIELD_SIZE(ATMARP_GLOBALS, pIPDelInterfaceRtn) }, { "pIPBindCompleteRtn", FIELD_OFFSET(ATMARP_GLOBALS, pIPBindCompleteRtn), FIELD_SIZE(ATMARP_GLOBALS, pIPBindCompleteRtn) }, #else #error "unimplemented" #endif // NEWARP { "Block", FIELD_OFFSET(ATMARP_GLOBALS, Block), FIELD_SIZE(ATMARP_GLOBALS, Block) }, #ifdef GPC #if DBG { "aaq_sig", FIELD_OFFSET(ATMARP_GLOBALS, aaq_sig), FIELD_SIZE(ATMARP_GLOBALS, aaq_sig) }, #endif { "pFlowInfoList", FIELD_OFFSET(ATMARP_GLOBALS, pFlowInfoList), FIELD_SIZE(ATMARP_GLOBALS, pFlowInfoList) }, { "GpcClientHandle", FIELD_OFFSET(ATMARP_GLOBALS, GpcClientHandle), FIELD_SIZE(ATMARP_GLOBALS, GpcClientHandle) }, { "bGpcInitialized", FIELD_OFFSET(ATMARP_GLOBALS, bGpcInitialized), FIELD_SIZE(ATMARP_GLOBALS, bGpcInitialized) }, { "GpcCalls", FIELD_OFFSET(ATMARP_GLOBALS, GpcCalls), FIELD_SIZE(ATMARP_GLOBALS, GpcCalls) }, #endif // GPC { NULL } }; TYPE_INFO type_ATMARP_GLOBALS = { "ATMARP_GLOBALS", "aag", typeid_ATMARP_GLOBALS, 0, sizeof(ATMARP_GLOBALS), rgfi_ATMARP_GLOBALS }; // // STRUCTURES CONCERNING TYPE "ATMARP_INTERFACE" // STRUCT_FIELD_INFO rgfi_ATMARP_INTERFACE[] = { #if DBG { "aai_sig", FIELD_OFFSET(ATMARP_INTERFACE, aai_sig), FIELD_SIZE(ATMARP_INTERFACE, aai_sig) }, #endif // struct _ATMARP_INTERFACE * pNextInterface; // in list of ATMARP interfaces { "pNextInterface", FIELD_OFFSET(ATMARP_INTERFACE, pNextInterface), FIELD_SIZE(ATMARP_INTERFACE, pNextInterface) }, // ULONG RefCount; // References to this interface { "RefCount", FIELD_OFFSET(ATMARP_INTERFACE, RefCount), FIELD_SIZE(ATMARP_INTERFACE, RefCount) }, // ULONG AdminState; // Desired state of this interface { "AdminState", FIELD_OFFSET(ATMARP_INTERFACE, AdminState), FIELD_SIZE(ATMARP_INTERFACE, AdminState) }, // ULONG State; // (Actual) State of this interface { "State", FIELD_OFFSET(ATMARP_INTERFACE, State), FIELD_SIZE(ATMARP_INTERFACE, State) }, #if (RECONFIG) //enum... ReconfigState; { "ReconfigState", FIELD_OFFSET(ATMARP_INTERFACE, ReconfigState), FIELD_SIZE(ATMARP_INTERFACE, ReconfigState) }, #endif // RECONFIG // ULONG Flags; // Misc state information { "Flags", FIELD_OFFSET(ATMARP_INTERFACE, Flags), FIELD_SIZE(ATMARP_INTERFACE, Flags) }, #if DBG // ULONG aaim_sig; // Signature to help debugging { "aaim_sig", FIELD_OFFSET(ATMARP_INTERFACE, aaim_sig), FIELD_SIZE(ATMARP_INTERFACE, aaim_sig) }, #endif // struct _ATMARP_INTERFACE * pAdapter; // Pointer to Adapter info { "pAdapter", FIELD_OFFSET(ATMARP_INTERFACE, pAdapter), FIELD_SIZE(ATMARP_INTERFACE, pAdapter) }, #if 0 // PCO_SAP pSap; // SAP info for this interface { "pSap", FIELD_OFFSET(ATMARP_INTERFACE, pSap), FIELD_SIZE(ATMARP_INTERFACE, pSap) }, #endif // 0 // ATMARP_SAP SapList; // Each SAP registered with CallMgr { "SapList", FIELD_OFFSET(ATMARP_INTERFACE, SapList), FIELD_SIZE(ATMARP_INTERFACE, SapList) }, // ATMARP_HEADER_POOL HeaderPool[AA_HEADER_TYPE_MAX]; { "HeaderPool", FIELD_OFFSET(ATMARP_INTERFACE, HeaderPool), FIELD_SIZE(ATMARP_INTERFACE, HeaderPool) }, // // ----- IP/ARP interface related ---- // #if DBG //ULONG aaia_sig; // Signature to help debugging { "aaia_sig", FIELD_OFFSET(ATMARP_INTERFACE, aaia_sig), FIELD_SIZE(ATMARP_INTERFACE, aaia_sig) }, #endif // PVOID IPContext; // Use in calls to IP { "IPContext", FIELD_OFFSET(ATMARP_INTERFACE, IPContext), FIELD_SIZE(ATMARP_INTERFACE, IPContext) }, // IP_ADDRESS_ENTRY LocalIPAddress; // List of local IP addresses. There { "LocalIPAddress", FIELD_OFFSET(ATMARP_INTERFACE, LocalIPAddress), FIELD_SIZE(ATMARP_INTERFACE, LocalIPAddress) }, // should be atleast one. //NDIS_STRING IPConfigString; // Config info for IP for this LIS { "IPConfigString", FIELD_OFFSET(ATMARP_INTERFACE, IPConfigString), FIELD_SIZE(ATMARP_INTERFACE, IPConfigString) }, // // ----- IP/ATM operation related ---- // #if DBG // ULONG aait_sig; // Signature to help debugging { "aait_sig", FIELD_OFFSET(ATMARP_INTERFACE, aait_sig), FIELD_SIZE(ATMARP_INTERFACE, aait_sig) }, #endif // PATMARP_IP_ENTRY * pArpTable; // The ARP table { "pArpTable", FIELD_OFFSET(ATMARP_INTERFACE, pArpTable), FIELD_SIZE(ATMARP_INTERFACE, pArpTable) }, // ULONG NumOfArpEntries; // Entries in the above { "NumOfArpEntries", FIELD_OFFSET(ATMARP_INTERFACE, NumOfArpEntries), FIELD_SIZE(ATMARP_INTERFACE, NumOfArpEntries) }, // ATMARP_SERVER_LIST ArpServerList; // List of ARP servers { "ArpServerList", FIELD_OFFSET(ATMARP_INTERFACE, ArpServerList), FIELD_SIZE(ATMARP_INTERFACE, ArpServerList) }, // PATMARP_SERVER_ENTRY pCurrentServer; // ARP server in use { "pCurrentServer", FIELD_OFFSET(ATMARP_INTERFACE, pCurrentServer), FIELD_SIZE(ATMARP_INTERFACE, pCurrentServer) }, // PATMARP_ATM_ENTRY pAtmEntryList; // List of all ATM Entries { "pAtmEntryList", FIELD_OFFSET(ATMARP_INTERFACE, pAtmEntryList), FIELD_SIZE(ATMARP_INTERFACE, pAtmEntryList) }, // ULONG AtmInterfaceUp; // The ATM interface is considered { "AtmInterfaceUp", FIELD_OFFSET(ATMARP_INTERFACE, AtmInterfaceUp), FIELD_SIZE(ATMARP_INTERFACE, AtmInterfaceUp) }, // "up" after ILMI addr regn is over // ATM_ADDRESS LocalAtmAddress; // Our ATM (HW) Address { "LocalAtmAddress", FIELD_OFFSET(ATMARP_INTERFACE, LocalAtmAddress), FIELD_SIZE(ATMARP_INTERFACE, LocalAtmAddress) }, // ATMARP_TIMER_LIST TimerList[AAT_CLASS_MAX]; { "TimerList", FIELD_OFFSET(ATMARP_INTERFACE, TimerList), FIELD_SIZE(ATMARP_INTERFACE, TimerList) }, #ifdef IPMCAST // // ---- IP Multicast over ATM stuff ---- // #if DBG //ULONG aaic_sig; // Signature for debugging { "aaic_sig", FIELD_OFFSET(ATMARP_INTERFACE, aaic_sig), FIELD_SIZE(ATMARP_INTERFACE, aaic_sig) }, #endif // DBG // ULONG IpMcState; // State of IP Multicast/ATM { "IpMcState", FIELD_OFFSET(ATMARP_INTERFACE, IpMcState), FIELD_SIZE(ATMARP_INTERFACE, IpMcState) }, // PATMARP_IPMC_JOIN_ENTRY pJoinList; // List of MC groups we have Joined { "pJoinList", FIELD_OFFSET(ATMARP_INTERFACE, pJoinList), FIELD_SIZE(ATMARP_INTERFACE, pJoinList) }, // PATMARP_IP_ENTRY pMcSendList; // Sorted list of MC groups we send to { "pMcSendList", FIELD_OFFSET(ATMARP_INTERFACE, pMcSendList), FIELD_SIZE(ATMARP_INTERFACE, pMcSendList) }, // ATMARP_SERVER_LIST MARSList; // List of MARS (servers) { "MARSList", FIELD_OFFSET(ATMARP_INTERFACE, MARSList), FIELD_SIZE(ATMARP_INTERFACE, MARSList) }, // PATMARP_SERVER_ENTRY pCurrentMARS; // MARS in use { "pCurrentMARS", FIELD_OFFSET(ATMARP_INTERFACE, pCurrentMARS), FIELD_SIZE(ATMARP_INTERFACE, pCurrentMARS) }, #endif // IPMCAST // PAA_GET_PACKET_SPEC_FUNC pGetPacketSpecFunc; // Routine to extract packet specs { "pGetPacketSpecFunc", FIELD_OFFSET(ATMARP_INTERFACE, pGetPacketSpecFunc), FIELD_SIZE(ATMARP_INTERFACE, pGetPacketSpecFunc) }, // PATMARP_FLOW_INFO pFlowInfoList; // List of configured flows { "pFlowInfoList", FIELD_OFFSET(ATMARP_INTERFACE, pFlowInfoList), FIELD_SIZE(ATMARP_INTERFACE, pFlowInfoList) }, #ifdef DHCP_OVER_ATM // BOOLEAN DhcpEnabled; { "DhcpEnabled", FIELD_OFFSET(ATMARP_INTERFACE, DhcpEnabled), FIELD_SIZE(ATMARP_INTERFACE, DhcpEnabled) }, // ATM_ADDRESS DhcpServerAddress; { "DhcpServerAddress", FIELD_OFFSET(ATMARP_INTERFACE, DhcpServerAddress), FIELD_SIZE(ATMARP_INTERFACE, DhcpServerAddress) }, // PATMARP_ATM_ENTRY pDhcpServerAtmEntry; { "pDhcpServerAtmEntry", FIELD_OFFSET(ATMARP_INTERFACE, pDhcpServerAtmEntry), FIELD_SIZE(ATMARP_INTERFACE, pDhcpServerAtmEntry) }, #endif // DHCP_OVER_ATM // // ---- WMI Information --- // #if ATMARP_WMI #if DBG // ULONG aaiw_sig; // Signature to help debugging { "aaiw_sig", FIELD_OFFSET(ATMARP_INTERFACE, aaiw_sig), FIELD_SIZE(ATMARP_INTERFACE, aaiw_sig) }, #endif // struct _ATMARP_IF_WMI_INFO *pIfWmiInfo; { "pIfWmiInfo", FIELD_OFFSET(ATMARP_INTERFACE, pIfWmiInfo), FIELD_SIZE(ATMARP_INTERFACE, pIfWmiInfo) }, #endif // ATMARP_WMI { NULL } }; TYPE_INFO type_ATMARP_INTERFACE = { "ATMARP_INTERFACE", "i", typeid_ATMARP_INTERFACE, fTYPEINFO_ISLIST, sizeof(ATMARP_INTERFACE), rgfi_ATMARP_INTERFACE, FIELD_OFFSET(ATMARP_INTERFACE, pNextInterface) // offset to next pointer. }; // // STRUCTURES CONCERNING TYPE "ATMARP_ATM_ENTRY" // BITFIELD_INFO rgAtmEntryFlagsInfo[] = { { "IDLE", AA_ATM_ENTRY_STATE_MASK, AA_ATM_ENTRY_IDLE }, { "ACTIVE", AA_ATM_ENTRY_STATE_MASK, AA_ATM_ENTRY_ACTIVE }, { "CLOSING", AA_ATM_ENTRY_STATE_MASK, AA_ATM_ENTRY_CLOSING }, { "UCAST", AA_ATM_ENTRY_TYPE_MASK, AA_ATM_ENTRY_TYPE_UCAST }, { "NUCAST", AA_ATM_ENTRY_TYPE_MASK, AA_ATM_ENTRY_TYPE_NUCAST }, { NULL } }; TYPE_INFO type_ATMARP_ATM_ENTRY_FLAGS = { "", "", typeid_NULL, fTYPEINFO_ISBITFIELD, sizeof(ULONG), NULL, 0, rgAtmEntryFlagsInfo }; STRUCT_FIELD_INFO rgfi_ATMARP_ATM_ENTRY[] = { #if DBG { "aae_sig", FIELD_OFFSET(ATMARP_ATM_ENTRY, aae_sig), FIELD_SIZE(ATMARP_ATM_ENTRY, aae_sig) }, #endif // struct _ATMARP_ATM_ENTRY * pNext; { "pNext", FIELD_OFFSET(ATMARP_ATM_ENTRY, pNext), FIELD_SIZE(ATMARP_ATM_ENTRY, pNext) }, // ULONG RefCount; // References { "RefCount", FIELD_OFFSET(ATMARP_ATM_ENTRY, RefCount), FIELD_SIZE(ATMARP_ATM_ENTRY, RefCount) }, // ULONG Flags; // Desired state of this interface { "Flags", FIELD_OFFSET(ATMARP_ATM_ENTRY, Flags), FIELD_SIZE(ATMARP_ATM_ENTRY, Flags), 0, // flags &type_ATMARP_ATM_ENTRY_FLAGS }, #if 0 // ULONG Lock; { "Lock", FIELD_OFFSET(ATMARP_ATM_ENTRY, Lock), FIELD_SIZE(ATMARP_ATM_ENTRY, Lock) }, #endif // struct _ATMARP_INTERFACE * pInterface; // Back pointer { "pInterface", FIELD_OFFSET(ATMARP_ATM_ENTRY, pInterface), FIELD_SIZE(ATMARP_ATM_ENTRY, pInterface) }, // struct _ATMARP_VC * pVcList; // List of VCs to this ATM { "pVcList", FIELD_OFFSET(ATMARP_ATM_ENTRY, pVcList), FIELD_SIZE(ATMARP_ATM_ENTRY, pVcList) }, // struct _ATMARP_VC * pBestEffortVc; // One of the Best Effort VCs here { "pBestEffortVc", FIELD_OFFSET(ATMARP_ATM_ENTRY, pBestEffortVc), FIELD_SIZE(ATMARP_ATM_ENTRY, pBestEffortVc) }, // struct _ATMARP_IP_ENTRY * pIpEntryList; // List of IP entries that { "pIpEntryList", FIELD_OFFSET(ATMARP_ATM_ENTRY, pIpEntryList), FIELD_SIZE(ATMARP_ATM_ENTRY, pIpEntryList) }, // ATM_ADDRESS ATMAddress; // "ATM Number" in the RFC { "ATMAddress", FIELD_OFFSET(ATMARP_ATM_ENTRY, ATMAddress), FIELD_SIZE(ATMARP_ATM_ENTRY, ATMAddress) }, #if 0 // ATM_ADDRESS ATMSubAddress; { "ATMSubAddress", FIELD_OFFSET(ATMARP_ATM_ENTRY, ATMSubAddress), FIELD_SIZE(ATMARP_ATM_ENTRY, ATMSubAddress) }, #endif // 0 #ifdef IPMCAST // struct _ATMARP_IPMC_ATM_INFO * pMcAtmInfo; // Additional info for multicast { "pMcAtmInfo", FIELD_OFFSET(ATMARP_ATM_ENTRY, pMcAtmInfo), FIELD_SIZE(ATMARP_ATM_ENTRY, pMcAtmInfo) }, #endif // IPMCAST #if DBG //UCHAR Refs[AE_REFTYPE_COUNT]; { "Refs", FIELD_OFFSET(ATMARP_ATM_ENTRY, Refs), FIELD_SIZE(ATMARP_ATM_ENTRY, Refs) }, #endif //DBG { NULL } }; TYPE_INFO type_ATMARP_ATM_ENTRY = { "ATMARP_ATM_ENTRY", "ae", typeid_ATMARP_ATM_ENTRY, fTYPEINFO_ISLIST, sizeof(ATMARP_ATM_ENTRY), rgfi_ATMARP_ATM_ENTRY, FIELD_OFFSET(ATMARP_ATM_ENTRY, pNext) // offset to next pointer. }; // // STRUCTURES CONCERNING TYPE "ATMARP_IP_ENTRY" // BITFIELD_INFO rgIpEntryFlagsInfo[] = { { "IDLE", AA_IP_ENTRY_STATE_MASK, AA_IP_ENTRY_IDLE }, { "ARPING", AA_IP_ENTRY_STATE_MASK, AA_IP_ENTRY_ARPING }, { "INARPING", AA_IP_ENTRY_STATE_MASK, AA_IP_ENTRY_INARPING }, { "RESOLVED", AA_IP_ENTRY_STATE_MASK, AA_IP_ENTRY_RESOLVED }, { "COMM_ERROR", AA_IP_ENTRY_STATE_MASK, AA_IP_ENTRY_COMM_ERROR }, { "ABORTING", AA_IP_ENTRY_STATE_MASK, AA_IP_ENTRY_ABORTING }, { "AGED_OUT", AA_IP_ENTRY_STATE_MASK, AA_IP_ENTRY_AGED_OUT }, { "SEEN_NAK", AA_IP_ENTRY_STATE_MASK, AA_IP_ENTRY_SEEN_NAK }, #ifdef IPMCAST #define MC AA_IP_ENTRY_ADDR_TYPE_NUCAST // // We use this to only dump other multicast-related fields // if this field is set. { "MC_NO_REVALIDATION", MC|AA_IP_ENTRY_MC_VALIDATE_MASK, MC|AA_IP_ENTRY_MC_NO_REVALIDATION }, { "MC_REVALIDATE", MC|AA_IP_ENTRY_MC_VALIDATE_MASK, MC|AA_IP_ENTRY_MC_REVALIDATE }, { "MC_REVALIDATING", MC|AA_IP_ENTRY_MC_VALIDATE_MASK, MC|AA_IP_ENTRY_MC_REVALIDATING }, { "MC_IDLE", MC|AA_IP_ENTRY_MC_RESOLVE_MASK, MC|AA_IP_ENTRY_MC_IDLE }, { "MC_AWAIT_MULTI", MC|AA_IP_ENTRY_MC_RESOLVE_MASK, MC|AA_IP_ENTRY_MC_AWAIT_MULTI }, { "MC_DISCARDING_MULTI", MC|AA_IP_ENTRY_MC_RESOLVE_MASK, MC|AA_IP_ENTRY_MC_DISCARDING_MULTI }, { "MC_RESOLVED", MC|AA_IP_ENTRY_MC_RESOLVE_MASK, MC|AA_IP_ENTRY_MC_RESOLVED }, { "UCAST", AA_IP_ENTRY_ADDR_TYPE_MASK, AA_IP_ENTRY_ADDR_TYPE_UCAST }, { "NUCAST", AA_IP_ENTRY_ADDR_TYPE_MASK, AA_IP_ENTRY_ADDR_TYPE_NUCAST }, #endif // IPMCAST { "STATIC", AA_IP_ENTRY_TYPE_MASK, AA_IP_ENTRY_IS_STATIC }, { NULL } }; TYPE_INFO type_ATMARP_IP_ENTRY_FLAGS = { "", "", typeid_NULL, fTYPEINFO_ISBITFIELD, sizeof(ULONG), NULL, 0, rgIpEntryFlagsInfo }; STRUCT_FIELD_INFO rgfi_ATMARP_IP_ENTRY[] = { #if DBG { "aip_sig", FIELD_OFFSET(ATMARP_IP_ENTRY, aip_sig), FIELD_SIZE(ATMARP_IP_ENTRY, aip_sig) }, #endif // IP_ADDRESS IPAddress; // IP Address { "IPAddress", FIELD_OFFSET(ATMARP_IP_ENTRY, IPAddress), FIELD_SIZE(ATMARP_IP_ENTRY, IPAddress) }, // struct _ATMARP_IP_ENTRY * pNextEntry; { "pNextEntry", FIELD_OFFSET(ATMARP_IP_ENTRY, pNextEntry), FIELD_SIZE(ATMARP_IP_ENTRY, pNextEntry) }, // struct _ATMARP_IP_ENTRY * pNextToAtm; // List of entries pointing to { "pNextToAtm", FIELD_OFFSET(ATMARP_IP_ENTRY, pNextToAtm), FIELD_SIZE(ATMARP_IP_ENTRY, pNextToAtm) }, // ULONG Flags; // Desired state of this interface { "Flags", FIELD_OFFSET(ATMARP_IP_ENTRY, Flags), FIELD_SIZE(ATMARP_IP_ENTRY, Flags), 0, // flags &type_ATMARP_IP_ENTRY_FLAGS }, // ULONG RefCount; // References { "RefCount", FIELD_OFFSET(ATMARP_IP_ENTRY, RefCount), FIELD_SIZE(ATMARP_IP_ENTRY, RefCount) }, #if 0 // ULONG Lock; { "Lock", FIELD_OFFSET(ATMARP_IP_ENTRY, Lock), FIELD_SIZE(ATMARP_IP_ENTRY, Lock) }, #endif // struct _ATMARP_INTERFACE * pInterface; // Back pointer { "pInterface", FIELD_OFFSET(ATMARP_IP_ENTRY, pInterface), FIELD_SIZE(ATMARP_IP_ENTRY, pInterface) }, // PATMARP_ATM_ENTRY pAtmEntry; // Pointer to all ATM info { "pAtmEntry", FIELD_OFFSET(ATMARP_IP_ENTRY, pAtmEntry), FIELD_SIZE(ATMARP_IP_ENTRY, pAtmEntry) }, #ifdef IPMCAST // struct _ATMARP_IP_ENTRY * pNextMcEntry; // Next "higher" Multicast IP Entry { "pNextMcEntry", FIELD_OFFSET(ATMARP_IP_ENTRY, pNextMcEntry), FIELD_SIZE(ATMARP_IP_ENTRY, pNextMcEntry) }, // USHORT NextMultiSeq; // Sequence Number expected { "NextMultiSeq", FIELD_OFFSET(ATMARP_IP_ENTRY, NextMultiSeq), FIELD_SIZE(ATMARP_IP_ENTRY, NextMultiSeq) }, // in the next MULTI #if 0 USHORT Filler; #endif // 0 #endif // IPMCAST // ATMARP_TIMER Timer; // Timers are: (all exclusive) { "Timer", FIELD_OFFSET(ATMARP_IP_ENTRY, Timer), FIELD_SIZE(ATMARP_IP_ENTRY, Timer) }, // ULONG RetriesLeft; { "RetriesLeft", FIELD_OFFSET(ATMARP_IP_ENTRY, RetriesLeft), FIELD_SIZE(ATMARP_IP_ENTRY, RetriesLeft) }, // PNDIS_PACKET PacketList; // List of packets waiting to be sent { "PacketList", FIELD_OFFSET(ATMARP_IP_ENTRY, PacketList), FIELD_SIZE(ATMARP_IP_ENTRY, PacketList) }, // RouteCacheEntry * pRCEList; // List of Route Cache Entries { "pRCEList", FIELD_OFFSET(ATMARP_IP_ENTRY, pRCEList), FIELD_SIZE(ATMARP_IP_ENTRY, pRCEList) }, #if 0 #ifdef CUBDD SINGLE_LIST_ENTRY PendingIrpList; // List of IRP's waiting for // this IP address to be resolved. #endif // CUBDD #endif// 0 #if DBG //UCHAR Refs[IE_REFTYPE_COUNT]; { "Refs", FIELD_OFFSET(ATMARP_IP_ENTRY, Refs), FIELD_SIZE(ATMARP_IP_ENTRY, Refs) }, #endif //DBG { NULL } }; TYPE_INFO type_ATMARP_IP_ENTRY = { "ATMARP_IP_ENTRY", "ip", typeid_ATMARP_IP_ENTRY, fTYPEINFO_ISLIST, sizeof(ATMARP_IP_ENTRY), rgfi_ATMARP_IP_ENTRY, FIELD_OFFSET(ATMARP_IP_ENTRY, pNextToAtm) // offset to next pointer. }; // // STRUCTURES CONCERNING TYPE "ATMARP_VC" // STRUCT_FIELD_INFO rgfi_ATMARP_VC[] = { #if DBG { "avc_sig", FIELD_OFFSET(ATMARP_VC, avc_sig), FIELD_SIZE(ATMARP_VC, avc_sig) }, #endif // struct _ATMARP_VC * pNextVc; { "pNextVc", FIELD_OFFSET(ATMARP_VC, pNextVc), FIELD_SIZE(ATMARP_VC, pNextVc) }, // ULONG RefCount; // References { "RefCount", FIELD_OFFSET(ATMARP_VC, RefCount), FIELD_SIZE(ATMARP_VC, RefCount) }, #if 0 // ULONG Lock; { "Lock", FIELD_OFFSET(ATMARP_VC, Lock), FIELD_SIZE(ATMARP_VC, Lock) }, #endif // ULONG Flags; // Desired state of this interface { "Flags", FIELD_OFFSET(ATMARP_VC, Flags), FIELD_SIZE(ATMARP_VC, Flags) }, // NDIS_HANDLE NdisVcHandle; // For NDIS calls { "NdisVcHandle", FIELD_OFFSET(ATMARP_VC, NdisVcHandle), FIELD_SIZE(ATMARP_VC, NdisVcHandle) }, // struct _ATMARP_INTERFACE * pInterface; // Back pointer { "pInterface", FIELD_OFFSET(ATMARP_VC, pInterface), FIELD_SIZE(ATMARP_VC, pInterface) }, // PATMARP_ATM_ENTRY pAtmEntry; // Pointer to all ATM info { "pAtmEntry", FIELD_OFFSET(ATMARP_VC, pAtmEntry), FIELD_SIZE(ATMARP_VC, pAtmEntry) }, // PNDIS_PACKET PacketList; // List of packets waiting to be sent { "PacketList", FIELD_OFFSET(ATMARP_VC, PacketList), FIELD_SIZE(ATMARP_VC, PacketList) }, // ATMARP_TIMER Timer; // Timers are: (all exclusive) { "Timer", FIELD_OFFSET(ATMARP_VC, Timer), FIELD_SIZE(ATMARP_VC, Timer) }, // ULONG RetriesLeft; { "RetriesLeft", FIELD_OFFSET(ATMARP_VC, RetriesLeft), FIELD_SIZE(ATMARP_VC, RetriesLeft) }, #ifdef GPC // PVOID FlowHandle; // Points to Flow Info struct { "FlowHandle", FIELD_OFFSET(ATMARP_VC, FlowHandle), FIELD_SIZE(ATMARP_VC, FlowHandle) }, #endif // GPC // ATMARP_FILTER_SPEC FilterSpec; // Filter Spec (Protocol, port) { "FilterSpec", FIELD_OFFSET(ATMARP_VC, FilterSpec), FIELD_SIZE(ATMARP_VC, FilterSpec) }, // ATMARP_FLOW_SPEC FlowSpec; // Flow Spec (QoS etc) for this conn { "FlowSpec", FIELD_OFFSET(ATMARP_VC, FlowSpec), FIELD_SIZE(ATMARP_VC, FlowSpec) }, { NULL } }; TYPE_INFO type_ATMARP_VC = { "ATMARP_VC", "vc", typeid_ATMARP_VC, fTYPEINFO_ISLIST, sizeof(ATMARP_VC), rgfi_ATMARP_VC, FIELD_OFFSET(ATMARP_VC, pNextVc) // offset to next pointer. }; TYPE_INFO *g_rgAAC_Types[] = { &type_ATMARP_GLOBALS, &type_ATMARP_ADAPTER, &type_ATMARP_INTERFACE, &type_ATMARP_ATM_ENTRY, &type_ATMARP_IP_ENTRY, &type_ATMARP_VC, NULL }; #if 0 typedef struct { const char *szName; // of variable. const char *szShortName; TYPE_INFO *pBaseType; // could be null (unspecified). UINT uFlags; UINT cbSize; UINT_PTR uAddr; // Address in debuggee's address space. } GLOBALVAR_INFO; #endif GLOBALVAR_INFO g_rgAAC_Globals[] = { { "AtmArpGlobalInfo", "aag", &type_ATMARP_GLOBALS, 0, sizeof(AtmArpGlobalInfo), 0 }, { "AtmArpProtocolCharacteristics", "pc", NULL, 0, sizeof(AtmArpProtocolCharacteristics), 0 }, { "AtmArpClientCharacteristics", "cc", NULL, 0, sizeof(AtmArpClientCharacteristics), 0 }, { NULL } }; UINT_PTR AAC_ResolveAddress( TYPE_INFO *pType ); NAMESPACE AAC_NameSpace = { g_rgAAC_Types, g_rgAAC_Globals, AAC_ResolveAddress }; void AAC_CmdHandler( DBGCOMMAND *pCmd ); void do_aac(PCSTR args) { DBGCOMMAND *pCmd = Parse(args, &AAC_NameSpace); if (pCmd) { //DumpCommand(pCmd); DoCommand(pCmd, AAC_CmdHandler); FreeCommand(pCmd); pCmd = NULL; } return; } void do_help(PCSTR args) { return; } void AAC_CmdHandler( DBGCOMMAND *pCmd ) { MyDbgPrintf("Handler called \n"); } UINT_PTR AAC_ResolveAddress( TYPE_INFO *pType ) { UINT_PTR uAddr = 0; UINT uOffset = 0; BOOL fRet = FALSE; UINT_PTR uParentAddress = 0; static UINT_PTR uAddr_AtmArpGlobalInfo; // // If this type has a parent (container) type, we will use the containing // type's cached address if its available, else we'll resolve the // containers type. The root types are globals -- we do an // expression evaluation for them. // switch(pType->uTypeID) { case typeid_ATMARP_GLOBALS: if (!uAddr_AtmArpGlobalInfo) { uAddr_AtmArpGlobalInfo = dbgextGetExpression("atmarpc!AtmArpGlobalInfo"); pType->uCachedAddress = uAddr_AtmArpGlobalInfo; } uAddr = uAddr_AtmArpGlobalInfo; if (uAddr) { fRet = TRUE; } break; case typeid_ATMARP_ADAPTER: // // // uParentAddress = type_ATMARP_GLOBALS.uCachedAddress; if (!uParentAddress) { uParentAddress = AAC_ResolveAddress(&type_ATMARP_GLOBALS); } if (uParentAddress) { uOffset = FIELD_OFFSET(ATMARP_GLOBALS, pAdapterList); fRet = dbgextReadUINT_PTR( uParentAddress+uOffset, &uAddr, "ATMARP_GLOBALS::pAdapterList" ); #if 0 MyDbgPrintf( "fRet = %lu; uParentOff=0x%lx uAddr=0x%lx[0x%lx]\n", fRet, uParentAddress+uOffset, uAddr, *(UINT_PTR*)(uParentAddress+uOffset) ); #endif // 0 } break; case typeid_ATMARP_INTERFACE: // // // uParentAddress = type_ATMARP_ADAPTER.uCachedAddress; if (!uParentAddress) { uParentAddress = AAC_ResolveAddress(&type_ATMARP_ADAPTER); } if (uParentAddress) { uOffset = FIELD_OFFSET(ATMARP_ADAPTER, pInterfaceList); fRet = dbgextReadUINT_PTR( uParentAddress + uOffset, &uAddr, "ATMARP_ADAPTER::pInterfaceList" ); #if 0 MyDbgPrintf( "fRet = %lu; uParentOff=0x%lx uAddr=0x%lx[0x%lx]\n", fRet, uParentAddress+uOffset, uAddr, *(UINT_PTR*)(uParentAddress+uOffset) ); #endif // 0 } break; case typeid_ATMARP_ATM_ENTRY: // // // uParentAddress = type_ATMARP_INTERFACE.uCachedAddress; if (!uParentAddress) { uParentAddress = AAC_ResolveAddress(&type_ATMARP_INTERFACE); } if (uParentAddress) { uOffset = FIELD_OFFSET(ATMARP_INTERFACE, pAtmEntryList); fRet = dbgextReadUINT_PTR( uParentAddress + uOffset, &uAddr, "ATMARP_INTERFACE::pAtmEntryList" ); #if 0 MyDbgPrintf( "fRet = %lu; uParentOff=0x%lx uAddr=0x%lx[0x%lx]\n", fRet, uParentAddress+uOffset, uAddr, *(UINT_PTR*)(uParentAddress+uOffset) ); #endif // 0 } break; case typeid_ATMARP_IP_ENTRY: // // // uParentAddress = type_ATMARP_ATM_ENTRY.uCachedAddress; if (!uParentAddress) { uParentAddress = AAC_ResolveAddress(&type_ATMARP_ATM_ENTRY); } if (uParentAddress) { uOffset = FIELD_OFFSET(ATMARP_ATM_ENTRY, pIpEntryList); fRet = dbgextReadUINT_PTR( uParentAddress + uOffset, &uAddr, "ATMARP_ATM_ENTRY::pIpEntryList" ); #if 0 MyDbgPrintf( "fRet = %lu; uParentOff=0x%lx uAddr=0x%lx[0x%lx]\n", fRet, uParentAddress+uOffset, uAddr, *(UINT_PTR*)(uParentAddress+uOffset) ); #endif // 0 } break; case typeid_ATMARP_VC: // // // uParentAddress = type_ATMARP_ATM_ENTRY.uCachedAddress; if (!uParentAddress) { uParentAddress = AAC_ResolveAddress(&type_ATMARP_ATM_ENTRY); } if (uParentAddress) { uOffset = FIELD_OFFSET(ATMARP_ATM_ENTRY, pVcList); fRet = dbgextReadUINT_PTR( uParentAddress + uOffset, &uAddr, "ATMARP_ATM_ENTRY::pVcList" ); #if 0 MyDbgPrintf( "fRet = %lu; uParentOff=0x%lx uAddr=0x%lx[0x%lx]\n", fRet, uParentAddress+uOffset, uAddr, *(UINT_PTR*)(uParentAddress+uOffset) ); #endif // 0 } break; default: MYASSERT(FALSE); break; } if (!fRet) { uAddr = 0; } MyDbgPrintf("ResolveAddress[%s] returns 0x%08lx\n", pType->szName, uAddr); return uAddr; }