windows-server-2003/net/atm/arp/kdext/aac.c

/*++

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;
}