#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <ntddser.h>

#include <windows.h>

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <malloc.h>

#include <rasman.h>
#include <dim.h>
#include <routprot.h>
#include <ipxrtdef.h>

// [pmay] this will no longer be neccessary when the ipx router
// is converted to use MprInfo api's.
typedef RTR_INFO_BLOCK_HEADER IPX_INFO_BLOCK_HEADER, *PIPX_INFO_BLOCK_HEADER;

VOID
PrintInterface(PIPX_INTERFACE	    ifp);

VOID
PrintRipInterface(PRIP_INTERFACE	    ifp);

typedef struct _RPNAM {

    ULONG	prot;
    PUCHAR	namep;

    } RPNAM, *PRPNAM;

RPNAM	ProtName[] = {

	{ IPX_PROTOCOL_LOCAL, "LOCAL" },
	{ IPX_PROTOCOL_STATIC, "STATIC"	},
	{ IPX_PROTOCOL_RIP, "RIP" },
	{ IPX_PROTOCOL_SAP, "SAP" }
	};

#define MAX_IPX_PROTOCOLS  sizeof(ProtName)/sizeof(RPNAM)

IPX_INTERFACE	    IpxIf;

VOID
GetIpxInterface(PDIM_ROUTER_INTERFACE	dimifp)
{
    ULONG	    ii;
    DWORD	    rc;
    IPX_MIB_GET_INPUT_DATA	    MibGetInputData;
    DWORD	    IfSize;

    IfSize = sizeof(IPX_INTERFACE);

    printf("Enter interface index:");
    scanf("%d", &ii);

    MibGetInputData.TableId = IPX_INTERFACE_TABLE;
    MibGetInputData.MibIndex.InterfaceTableIndex.InterfaceIndex = ii;

    rc = (*(dimifp->MIBEntryGet))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&IfSize,
				&IpxIf);


    if(rc != NO_ERROR) {

	printf("MibEntryGet: failed rc = %d\n", rc);
	return;
    }

    PrintInterface(&IpxIf);
}

VOID
GetRipInterface(PDIM_ROUTER_INTERFACE	dimifp)
{
    DWORD			rc;
    ULONG			IfSize;
    RIP_MIB_GET_INPUT_DATA	RipMibGetInputData;
    RIP_INTERFACE		RipIf;

    printf("Enter interface index:");
    scanf("%d", &RipMibGetInputData.InterfaceIndex);

    RipMibGetInputData.TableId = RIP_INTERFACE_TABLE;

    rc = (*(dimifp->MIBEntryGet))(
				IPX_PROTOCOL_RIP,
				sizeof(RIP_MIB_GET_INPUT_DATA),
				&RipMibGetInputData,
				&IfSize,
				&RipIf);


    if(rc != NO_ERROR) {

	printf("MibEntryGet: failed rc = %d\n", rc);
	return;
    }

    PrintRipInterface(&RipIf);
}


VOID
GetRipFilters(PDIM_ROUTER_INTERFACE	dimifp)
{
    DWORD			rc;
    ULONG			GlobalInfoSize, i;
    RIP_MIB_GET_INPUT_DATA	RipMibGetInputData;
    PRIP_GLOBAL_INFO		RipGlobalInfop;
    PRIP_ROUTE_FILTER_INFO	rfip;
    char			*action;

    RipMibGetInputData.TableId = RIP_GLOBAL_INFO_ENTRY;

    rc = (*(dimifp->MIBEntryGet))(
				IPX_PROTOCOL_RIP,
				sizeof(RIP_MIB_GET_INPUT_DATA),
				&RipMibGetInputData,
				&GlobalInfoSize,
				NULL);

    if(rc != ERROR_INSUFFICIENT_BUFFER) {

	printf("MibEntryGet: failed rc = %d\n", rc);
	return;
    }

    RipGlobalInfop = GlobalAlloc(GPTR, GlobalInfoSize);

    rc = (*(dimifp->MIBEntryGet))(
				IPX_PROTOCOL_RIP,
				sizeof(RIP_MIB_GET_INPUT_DATA),
				&RipMibGetInputData,
				&GlobalInfoSize,
				RipGlobalInfop);

    if(rc != NO_ERROR) {

	printf("MibEntryGet: failed rc = %d\n", rc);
	return;
    }

    if(RipGlobalInfop->RouteFiltersCount == 0) {

	printf("No Filters\n");
	return;
    }

    if(RipGlobalInfop->RouteFilterAction == IPX_ROUTE_FILTER_ADVERTISE) {

	action = "ADVERTISE";
    }
    else
    {
	action = "SUPPRESS";
    }

    printf("There are %d RIP filters configured for %s\n",
	    RipGlobalInfop->RouteFiltersCount,
	    action);

    for(i=0, rfip=RipGlobalInfop->RouteFilter;
	i<RipGlobalInfop->RouteFiltersCount;
	i++, rfip++)
    {
	printf("Route filter # %d Network %.2x%.2x%.2x%.2x\n",
	       i,
	       rfip->Network[0],
	       rfip->Network[1],
	       rfip->Network[2],
	       rfip->Network[3]);
    }

    GlobalFree(RipGlobalInfop);
}



VOID
PrintInterface(PIPX_INTERFACE	    ifp)
{
    char *iftype;
    char *admin;
    char *oper;

    switch(ifp->InterfaceType) {

	case IF_TYPE_WAN_WORKSTATION:

	    iftype ="WAN WORKSTATION";
	    break;

	case IF_TYPE_WAN_ROUTER:

	    iftype = "WAN ROUTER";
	    break;

	case IF_TYPE_LAN:

	    iftype = "LAN";
	    break;

	case IF_TYPE_INTERNAL:

	    iftype = "INTERNAL";
	    break;

	default:

	    iftype = "UNKNOWN";
	    break;

    }

    switch(ifp->AdminState) {

	case ADMIN_STATE_ENABLED:

	    admin = "ENABLED";
	    break;

	case ADMIN_STATE_DISABLED:

	    admin = "DISABLED";
	    break;

	default:

	    admin = "UNKNOWN";
	    break;
    }

    switch(ifp->IfStats.IfOperState) {

	case OPER_STATE_UP:

	    oper = "UP";
	    break;

	case OPER_STATE_DOWN:

	    oper = "DOWN";
	    break;

	case OPER_STATE_SLEEPING:

	    oper = "SLEEPING";
	    break;

	default:

	    oper = "UNKNOWN";
	    break;
    }

    printf("\n");
    printf("Interface Index: %d\n", ifp->InterfaceIndex);
    printf("Name: %s\n", ifp->InterfaceName);
    printf("Type: %s\n", iftype);
    printf("Network Number: %.2x%.2x%.2x%.2x\n",
	    ifp->NetNumber[0],
	    ifp->NetNumber[1],
	    ifp->NetNumber[2],
	    ifp->NetNumber[3]);
    printf("Admin State: %s\n", admin);
    printf("Oper State: %s\n\n", oper);
}

#define REPORT_RIP_CONFIG_STATE(report, config)    \
	switch((config)) {\
	case ADMIN_STATE_ENABLED:\
	    (report) = "ENABLED";\
	    break;\
	case ADMIN_STATE_DISABLED:\
	    (report) = "DISABLED";\
	    break;\
	default:\
	    (report) = "UNKNOWN";\
	    break;\
	}

VOID
PrintRipInterface(PRIP_INTERFACE	    ifp)
{
    char *admin;
    char *oper;
    char *filtering;
    char *supply;
    char *listen;
    char *update;

    REPORT_RIP_CONFIG_STATE(admin, ifp->RipIfInfo.AdminState);
    REPORT_RIP_CONFIG_STATE(supply, ifp->RipIfInfo.Supply);
    REPORT_RIP_CONFIG_STATE(listen, ifp->RipIfInfo.Listen);
    REPORT_RIP_CONFIG_STATE(filtering, ifp->RipIfInfo.EnableGlobalFiltering);
    switch(ifp->RipIfStats.RipIfOperState) {

	case OPER_STATE_UP:

	    oper = "UP";
	    break;

	case OPER_STATE_DOWN:

	    oper = "DOWN";
	    break;

	case OPER_STATE_SLEEPING:

	    oper = "SLEEPING";
	    break;

	default:

	    oper = "UNKNOWN";
	    break;
    }
    switch(ifp->RipIfInfo.UpdateMode) {

	case IPX_STANDARD_UPDATE:

	    update = "STANDARD";
	    break;

	case IPX_NO_UPDATE:

	    update = "NO UPDATE";
	    break;

	case IPX_AUTO_STATIC_UPDATE:

	    update = "AUTO-STATIC";
	    break;

	default:

	    break;
    }

    printf("\n");
    printf("Interface Index: %d\n", ifp->InterfaceIndex);
    printf("Admin State: %s\n", admin);
    printf("Oper State: %s\n", oper);
    printf("Supply RIP advertisments: %s\n", supply);
    printf("Listen to RIP advertisments: %s\n", listen);
    printf("Enable Global RIP Filtering: %s\n", filtering);
    printf("Update Mode: %s\n", update);
    printf("RIP packets recv: %d\n", ifp->RipIfStats.RipIfInputPackets);
    printf("RIP packets sent: %d\n\n", ifp->RipIfStats.RipIfOutputPackets);
}

VOID
EnumerateIpxInterfaces(PDIM_ROUTER_INTERFACE   dimifp)
{
    DWORD	   rc;
    IPX_MIB_GET_INPUT_DATA	    MibGetInputData;
    DWORD	    IfSize;

    IfSize = sizeof(IPX_INTERFACE);

    MibGetInputData.TableId = IPX_INTERFACE_TABLE;
    MibGetInputData.MibIndex.InterfaceTableIndex.InterfaceIndex = 0;

    rc = (*(dimifp->MIBEntryGetFirst))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&IfSize,
				&IpxIf);


    if(rc != NO_ERROR) {

	printf("MIBEntryGetFirst: failed rc = %d\n", rc);
	return;
    }

    PrintInterface(&IpxIf);

    for(;;)
    {
	MibGetInputData.MibIndex.InterfaceTableIndex.InterfaceIndex = IpxIf.InterfaceIndex;

	rc = (*(dimifp->MIBEntryGetNext))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&IfSize,
				&IpxIf);

	if(rc != NO_ERROR) {

	    printf("EnumerateIpxInterfaces: MIBEntryGetNext failed rc= 0x%x\n", rc);
	    return;
	}

	PrintInterface(&IpxIf);
    }
}


IPX_ROUTE	Route;

VOID
PrintRoute(VOID);

VOID
EnumerateAllBestRoutes(PDIM_ROUTER_INTERFACE   dimifp)
{
    DWORD			    rc;
    IPX_MIB_GET_INPUT_DATA	    MibGetInputData;
    DWORD			    RtSize;

    RtSize = sizeof(IPX_ROUTE);

    MibGetInputData.TableId = IPX_DEST_TABLE;
    memset(MibGetInputData.MibIndex.RoutingTableIndex.Network, 0, 4);

    rc = (*(dimifp->MIBEntryGetFirst))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&RtSize,
				&Route);


    if(rc != NO_ERROR) {

	printf("MIBEntryGetFirst: failed rc = %d\n", rc);
	return;
    }

    PrintRoute();

    for(;;)
    {
	memcpy(MibGetInputData.MibIndex.RoutingTableIndex.Network, Route.Network, 4);

	rc = (*(dimifp->MIBEntryGetNext))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&RtSize,
				&Route);

	if(rc != NO_ERROR) {

	    printf("MIBEntryGetNext failed rc= 0x%x\n", rc);
	    return;
	}

	PrintRoute();
    }
}

VOID
PrintRoute(VOID)
{
    int i;
    PUCHAR     pn = "BOGUS";

    for(i=0; i<MAX_IPX_PROTOCOLS; i++) {

	if(ProtName[i].prot == Route.Protocol) {

	    pn = ProtName[i].namep;
	    break;
	}
    }

    printf("Route: if # 0x%x, prot %s net %.2x%.2x%.2x%.2x ticks %d hops %d nexthop %.2x%.2x%.2x%.2x%.2x%.2x\n",
	    Route.InterfaceIndex,
	    pn,
	    Route.Network[0],
	    Route.Network[1],
	    Route.Network[2],
	    Route.Network[3],
	    Route.TickCount,
	    Route.HopCount,
	    Route.NextHopMacAddress[0],
	    Route.NextHopMacAddress[1],
	    Route.NextHopMacAddress[2],
	    Route.NextHopMacAddress[3],
	    Route.NextHopMacAddress[4],
	    Route.NextHopMacAddress[5]);
}

VOID
EnumerateStaticRoutes(PDIM_ROUTER_INTERFACE	 dimifp)
{
    DWORD			    rc;
    IPX_MIB_GET_INPUT_DATA	    MibGetInputData;
    DWORD			    RtSize;

    RtSize = sizeof(IPX_ROUTE);

    MibGetInputData.TableId = IPX_STATIC_ROUTE_TABLE;
    MibGetInputData.MibIndex.StaticRoutesTableIndex.InterfaceIndex = 0;
    memset(MibGetInputData.MibIndex.StaticRoutesTableIndex.Network, 0, 4);

    rc = (*(dimifp->MIBEntryGetFirst))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&RtSize,
				&Route);


    if(rc != NO_ERROR) {

	printf("MIBEntryGetFirst: failed rc = %d\n", rc);
	return;
    }

    PrintRoute();

    for(;;)
    {
	memcpy(MibGetInputData.MibIndex.StaticRoutesTableIndex.Network, Route.Network, 4);
	MibGetInputData.MibIndex.StaticRoutesTableIndex.InterfaceIndex = Route.InterfaceIndex;

	rc = (*(dimifp->MIBEntryGetNext))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&RtSize,
				&Route);

	if(rc != NO_ERROR) {

	    printf("MIBEntryGetNext failed rc= 0x%x\n", rc);
	    return;
	}

	PrintRoute();
    }
}


IPX_SERVICE	    Service;

VOID
PrintService(VOID)
{
    int i;
    PUCHAR     pn = "BOGUS";

    for(i=0; i<MAX_IPX_PROTOCOLS; i++) {

	if(ProtName[i].prot == Service.Protocol) {

	    pn = ProtName[i].namep;
	    break;
	}
    }

    printf("Service if # %d prot %s type %d name %s\n",
	   Service.InterfaceIndex,
	   pn,
	   Service.Server.Type,
	   Service.Server.Name);
}

VOID
EnumerateAllServers(PDIM_ROUTER_INTERFACE	 dimifp)
{
    DWORD			    rc;
    IPX_MIB_GET_INPUT_DATA	    MibGetInputData;
    DWORD			    SvSize;

    SvSize = sizeof(IPX_SERVICE);

    MibGetInputData.TableId = IPX_SERV_TABLE;
    MibGetInputData.MibIndex.ServicesTableIndex.ServiceType = 0;
    memset(MibGetInputData.MibIndex.ServicesTableIndex.ServiceName, 0, 48);

    rc = (*(dimifp->MIBEntryGetFirst))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&SvSize,
				&Service);


    if(rc != NO_ERROR) {

	printf("MIBEntryGetFirst: failed rc = %d\n", rc);
	return;
    }

    PrintService();

    for(;;)
    {
	MibGetInputData.MibIndex.ServicesTableIndex.ServiceType =  Service.Server.Type;
	memcpy(MibGetInputData.MibIndex.ServicesTableIndex.ServiceName, Service.Server.Name, 48);

	rc = (*(dimifp->MIBEntryGetNext))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&SvSize,
				&Service);

	if(rc != NO_ERROR) {

	    printf("MIBEntryGetNext failed rc= 0x%x\n", rc);
	    return;
	}

	PrintService();
    }
}

VOID
EnumerateAllServersOfType(PDIM_ROUTER_INTERFACE	 dimifp,
			  USHORT		 Type)
{
    DWORD			    rc;
    IPX_MIB_GET_INPUT_DATA	    MibGetInputData;
    DWORD			    SvSize;

    SvSize = sizeof(IPX_SERVICE);

    MibGetInputData.TableId = IPX_SERV_TABLE;
    MibGetInputData.MibIndex.ServicesTableIndex.ServiceType = Type;
    memset(MibGetInputData.MibIndex.ServicesTableIndex.ServiceName, ' ', 40);

    for(;;)
    {
	rc = (*(dimifp->MIBEntryGetNext))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&SvSize,
				&Service);

	if(rc != NO_ERROR) {

	    printf("MIBEntryGetNext failed rc= 0x%x\n", rc);
	    return;
	}

	if(Service.Server.Type != Type)
	{
	    return;
	}

	PrintService();
	memcpy(MibGetInputData.MibIndex.ServicesTableIndex.ServiceName, Service.Server.Name, 48);
    }
}

VOID
EnumerateStaticServers(PDIM_ROUTER_INTERFACE	 dimifp)
{
    DWORD			    rc;
    IPX_MIB_GET_INPUT_DATA	    MibGetInputData;
    DWORD			    SvSize;

    SvSize = sizeof(IPX_SERVICE);

    MibGetInputData.TableId = IPX_STATIC_SERV_TABLE;
    MibGetInputData.MibIndex.StaticServicesTableIndex.InterfaceIndex = 0;
    MibGetInputData.MibIndex.StaticServicesTableIndex.ServiceType = 0;
    memset(MibGetInputData.MibIndex.ServicesTableIndex.ServiceName, 0, 48);

    rc = (*(dimifp->MIBEntryGetFirst))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&SvSize,
				&Service);


    if(rc != NO_ERROR) {

	printf("MIBEntryGetFirst: failed rc = %d\n", rc);
	return;
    }

    PrintService();

    for(;;)
    {
	MibGetInputData.MibIndex.StaticServicesTableIndex.InterfaceIndex = Service.InterfaceIndex;
	MibGetInputData.MibIndex.StaticServicesTableIndex.ServiceType =	Service.Server.Type;
	memcpy(MibGetInputData.MibIndex.StaticServicesTableIndex.ServiceName, Service.Server.Name, 48);

	rc = (*(dimifp->MIBEntryGetNext))(
				IPX_PROTOCOL_BASE,
				sizeof(IPX_MIB_GET_INPUT_DATA),
				&MibGetInputData,
				&SvSize,
				&Service);

	if(rc != NO_ERROR) {

	    printf("MIBEntryGetNext failed rc= 0x%x\n", rc);
	    return;
	}

	PrintService();
    }
}

VOID
TestMib(PDIM_ROUTER_INTERFACE	dimifp)
{
    int 	i;
    int 	Type;

    for(;;) {

	printf("    MIB TEST OPTIONS MENU:\n");
	printf("1. MIB TEST - Get IPX interface\n");
	printf("2. MIB TEST - Enumerate IPX Interfaces\n");
	printf("3. MIB TEST - Enumerate all best routes\n");
	printf("4. MIB TEST - Enumerate static routes\n");
	printf("5. MIB TEST - Enumerate all servers\n");
	printf("6. MIB TEST - Enumerate all servers of the specified type\n");
	printf("7. MIB TEST - Enumerate all static servers\n");
	printf("8. MIB TEST - Get RIP Interface\n");
	printf("9. MIB TEST - Get RIP Filters\n");
	printf("99. MIB TEST - return to main menu\n");
	printf("Enter your option:");
	scanf("%d", &i);

	switch(i)
	{
	    case 1:

		GetIpxInterface(dimifp);
		break;

	    case 2:

		EnumerateIpxInterfaces(dimifp);
		break;

	    case 3:

		EnumerateAllBestRoutes(dimifp);
		break;

	    case 4:

		EnumerateStaticRoutes(dimifp);
		break;

	    case 5:

		EnumerateAllServers(dimifp);
		break;

	    case 6:

		printf("Enter server type:");
		scanf("%d", &Type);

		EnumerateAllServersOfType(dimifp, (USHORT)Type);
		break;

	    case 7:

		EnumerateStaticServers(dimifp);
		break;

	    case 8:

		GetRipInterface(dimifp);
		break;

	    case 9:

		GetRipFilters(dimifp);
		break;

	    case 99:

		return;

	    default:

		break;
	}
    }
}