able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/rras/ip/rip/riptest.cxx

1921 lines
42 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//============================================================================
// Copyright (c) 1995, Microsoft Corporation
//
// File: riptest.cxx
//
// History:
// Abolade Gbadegesin Oct-16-1995 Created.
//
// Code for RIP test program
//============================================================================
extern "C" {
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <winsvc.h>
#define FD_SETSIZE 256
#include <winsock.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <ipexport.h>
#include <ipinfo.h>
#include <llinfo.h>
#include <rtm.h>
#include <routprot.h>
#include <mprerror.h>
#include <rtutils.h>
#include <ipriprm.h>
#include <iprtrmib.h>
#include <dim.h>
#include <mprapi.h>
#include <iphlpapi.h>
#include "defs.h"
#include "riptest.h"
DWORD g_TraceID;
RIPTEST_IF_CONFIG g_cfg;
RIPTEST_IF_CONFIG g_def = {
50, // 50 routes
0x000000c0, // starting with 192.0.0.0
0x0000ffff, // using netmask 255.255.0.0
0x00000000, // and a next hop of 0
0x00000000, // and a route-tag of 0
0xffffffff, // sent to the broadcast address
0, // don't use a timeout to remove routes
2, // send version 2 packets
0, // random-sized packets
100, // use 100-millisecond packet gap
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", // all-zeroes authentication key
IPRIP_AUTHTYPE_NONE, // no authentication
262144 // and set the send and recv buffers to this size
};
DWORD g_seed;
RIPTEST_IF_BINDING g_bind;
REG_OPTION g_options[] = {
{
STR_ROUTECOUNT,
sizeof(DWORD),
&g_cfg.RIC_RouteCount,
&g_def.RIC_RouteCount,
RegGetDWORD
},
{
STR_ROUTESTART,
sizeof(DWORD),
&g_cfg.RIC_RouteStart,
&g_def.RIC_RouteStart,
RegGetAddress
},
{
STR_ROUTEMASK,
sizeof(DWORD),
&g_cfg.RIC_RouteMask,
&g_def.RIC_RouteMask,
RegGetAddress
},
{
STR_ROUTENEXTHOP,
sizeof(DWORD),
&g_cfg.RIC_RouteNexthop,
&g_def.RIC_RouteNexthop,
RegGetAddress
},
{
STR_ROUTETAG,
sizeof(DWORD),
&g_cfg.RIC_RouteTag,
&g_def.RIC_RouteTag,
RegGetDWORD
},
{
STR_ROUTETARGET,
sizeof(DWORD),
&g_cfg.RIC_RouteTarget,
&g_def.RIC_RouteTarget,
RegGetAddress
},
{
STR_ROUTETIMEOUT,
sizeof(DWORD),
&g_cfg.RIC_RouteTimeout,
&g_def.RIC_RouteTimeout,
RegGetDWORD
},
{
STR_PACKETVERSION,
sizeof(DWORD),
&g_cfg.RIC_PacketVersion,
&g_def.RIC_PacketVersion,
RegGetDWORD
},
{
STR_PACKETENTRYCOUNT,
sizeof(DWORD),
&g_cfg.RIC_PacketEntryCount,
&g_def.RIC_PacketEntryCount,
RegGetDWORD
},
{
STR_PACKETGAP,
sizeof(DWORD),
&g_cfg.RIC_PacketGap,
&g_def.RIC_PacketGap,
RegGetDWORD
},
{
STR_AUTHKEY,
IPRIP_MAX_AUTHKEY_SIZE,
g_cfg.RIC_AuthKey,
g_def.RIC_AuthKey,
RegGetBinary
},
{
STR_AUTHTYPE,
sizeof(DWORD),
&g_cfg.RIC_AuthType,
&g_def.RIC_AuthType,
RegGetDWORD
},
{
STR_SOCKBUFSIZE,
sizeof(DWORD),
&g_cfg.RIC_SockBufSize,
&g_def.RIC_SockBufSize,
RegGetDWORD
}
};
INT __cdecl
main(
INT iArgc,
PSTR ppszArgv[]
)
{
WSADATA wd;
DWORD dwErr;
//
// must be at least one argument
//
if (iArgc != 2) {
PrintUsage();
return ERROR_INVALID_PARAMETER;
}
//
// see if the user is just asking for instructions
//
if (strcmp(ppszArgv[1], "-?") == 0 || strcmp(ppszArgv[1], "/?") == 0) {
PrintUsage();
return 0;
}
//
// first and only argument is name of interface
//
mbstowcs(g_bind.RIB_Netcard, ppszArgv[1], mbstowcs(NULL, ppszArgv[1], -1));
//
// register with the Tracing DLL
//
g_TraceID = PRINTREGISTER("RipTest");
//
// startup Winsock
//
dwErr = WSAStartup(MAKEWORD(1, 1), &wd);
if (dwErr != NO_ERROR) {
PRINTDEREGISTER(g_TraceID);
return (INT)dwErr;
}
//
// get the binding for the interface over which to send routes
//
dwErr = RegGetIfBinding();
if (dwErr != NO_ERROR) {
WSACleanup();
PRINTDEREGISTER(g_TraceID);
return (INT)dwErr;
}
//
// seed the random number generator
//
g_seed = GetTickCount();
srand(g_seed);
while (TRUE) {
PRINT0("\n\nbeginning test cycle...");
//
// get the parameters for the interface,
// and quit if an error occurred or the defaults were written
//
dwErr = RegGetConfig();
if (dwErr != NO_ERROR) { break; }
//
// run one test cycle
//
dwErr = RipTest();
PRINT0("completed test cycle...");
}
WSACleanup();
PRINTDEREGISTER(g_TraceID);
return dwErr;
}
DWORD
RegGetIfBinding(
VOID
)
{
#if 1
PMIB_IPADDRTABLE AddrTable = NULL;
DWORD dwErr;
DWORD dwPrefixLength = lstrlen("\\DEVICE\\TCPIP_");
DWORD dwSize;
DWORD i;
DWORD j;
PIP_INTERFACE_INFO IfTable = NULL;
//
// Load the address table and interface table
//
do {
dwSize = 0;
dwErr = GetInterfaceInfo(IfTable, &dwSize);
if (dwErr != ERROR_INSUFFICIENT_BUFFER) {
PRINT1("error %d obtaining interface-table size", dwErr);
break;
}
IfTable = (PIP_INTERFACE_INFO)HeapAlloc(GetProcessHeap(), 0, dwSize);
if (!IfTable) {
dwErr = GetLastError();
PRINT2("error %d allocating %d-byte for interfaces", dwErr, dwSize);
dwErr = ERROR_INSUFFICIENT_BUFFER; break;
}
dwErr = GetInterfaceInfo(IfTable, &dwSize);
if (dwErr != NO_ERROR) {
PRINT1("error %d getting interface table", dwErr);
break;
}
dwSize = 0;
dwErr = GetIpAddrTable(AddrTable, &dwSize, FALSE);
if (dwErr != ERROR_INSUFFICIENT_BUFFER) {
PRINT1("error %d obtaining address-table size", dwErr);
break;
}
AddrTable = (PMIB_IPADDRTABLE)HeapAlloc(GetProcessHeap(), 0, dwSize);
if (!AddrTable) {
dwErr = GetLastError();
PRINT2("error %d allocating %d-byte for addresses", dwErr, dwSize);
dwErr = ERROR_INSUFFICIENT_BUFFER; break;
}
dwErr = GetIpAddrTable(AddrTable, &dwSize, FALSE);
if (dwErr != NO_ERROR) {
PRINT1("error %d getting address table", dwErr);
break;
}
} while(FALSE);
if (dwErr != NO_ERROR) {
if (IfTable) { HeapFree(GetProcessHeap(), 0, IfTable); }
if (AddrTable) { HeapFree(GetProcessHeap(), 0, AddrTable); }
return dwErr;
}
//
// Find the user's interface in the interface-table
//
dwErr = ERROR_INVALID_PARAMETER;
for (i = 0; i < (DWORD)IfTable->NumAdapters; i++) {
PRINT2("%d: %ls", IfTable->Adapter[i].Index, IfTable->Adapter[i].Name+dwPrefixLength);
if (lstrcmpiW(
IfTable->Adapter[i].Name+dwPrefixLength, g_bind.RIB_Netcard
) != 0) {
continue;
}
//
// We've found the interface.
// Now look in the address-table for its address.
//
for (j = 0; j < AddrTable->dwNumEntries; j++) {
PRINT2("%d: %s", AddrTable->table[j].dwIndex, INET_NTOA(AddrTable->table[j].dwAddr));
if (AddrTable->table[j].dwIndex != IfTable->Adapter[i].Index) {
continue;
}
//
// We've found the address.
//
g_bind.RIB_Address = AddrTable->table[j].dwAddr;
g_bind.RIB_Netmask = AddrTable->table[j].dwMask;
dwErr = NO_ERROR;
break;
}
if (j >= AddrTable->dwNumEntries) {
PRINT0("the address for the interface could not be found");
}
break;
}
if (i >= (DWORD)IfTable->NumAdapters) {
PRINT0("the interface specified could not be found");
}
HeapFree(GetProcessHeap(), 0, IfTable);
HeapFree(GetProcessHeap(), 0, AddrTable);
return dwErr;
#else
HKEY hkeyNetcard;
PSTR pszAddress, pszNetmask;
CHAR szNetcard[256], szValue[256];
DWORD dwErr, dwType, dwSize, dwEnableDhcp;
//
// open the TCP/IP parameters key for the interface specified
//
strcpy(szNetcard, STR_SERVICES);
strcat(szNetcard, g_bind.RIB_Netcard);
strcat(szNetcard, STR_PARAMSTCP);
dwErr = RegOpenKeyEx(
HKEY_LOCAL_MACHINE, szNetcard, 0, KEY_ALL_ACCESS, &hkeyNetcard
);
if (dwErr != NO_ERROR) {
PRINT2("error %d opening registry key %s", dwErr, szNetcard);
return dwErr;
}
do {
//
// read the dhcp key to see whether DHCP is enabled
//
dwSize = sizeof(DWORD);
dwErr = RegQueryValueEx(
hkeyNetcard, STR_ENABLEDHCP, NULL,
&dwType, (PBYTE)&dwEnableDhcp, &dwSize
);
if (dwErr != NO_ERROR) {
PRINT3(
"error %d reading value %s under key %s",
dwErr, STR_ENABLEDHCP, szNetcard
);
break;
}
if (dwEnableDhcp) {
pszAddress = STR_DHCPADDR;
pszNetmask = STR_DHCPMASK;
}
else {
pszAddress = STR_ADDRESS;
pszNetmask = STR_NETMASK;
}
//
// read the IP address and convert it
//
dwSize = sizeof(szValue);
dwErr = RegQueryValueEx(
hkeyNetcard, pszAddress, NULL,
&dwType, (PBYTE)szValue, &dwSize
);
if (dwErr != NO_ERROR) {
PRINT3(
"error %d reading value %s under key %s",
dwErr, pszAddress, szNetcard
);
break;
}
g_bind.RIB_Address = inet_addr(szValue);
PRINT2("%s == %s", pszAddress, szValue);
//
// read the network mask and convert it
//
dwSize = sizeof(szValue);
dwErr = RegQueryValueEx(
hkeyNetcard, pszNetmask, NULL,
&dwType, (PBYTE)szValue, &dwSize
);
if (dwErr != NO_ERROR) {
PRINT3(
"error %d reading value %s under key %s",
dwErr, pszNetmask, szNetcard
);
break;
}
g_bind.RIB_Netmask = inet_addr(szValue);
PRINT2("%s == %s", pszNetmask, szValue);
} while(FALSE);
RegCloseKey(hkeyNetcard);
return dwErr;
#endif
}
DWORD
RegGetConfig(
VOID
)
{
CHAR szRipTest[256];
DWORD dwErr, dwCreated;
PREG_OPTION pro, proend;
HKEY hkeyRipTest, hkeyIf;
DWORD dwNetmask, dwPrefixLength;
DWORD dwCount, dwLowestAddress, dwHighestAddress;
//
// create the RipTest key in case it doesn't exist
//
strcpy(szRipTest, STR_SERVICES);
strcat(szRipTest, STR_RIPTEST);
dwErr = RegCreateKeyEx(
HKEY_LOCAL_MACHINE, szRipTest, 0, NULL, 0,
KEY_ALL_ACCESS, NULL, &hkeyRipTest, &dwCreated
);
if (dwErr != NO_ERROR) {
PRINT2("error %d creating registry key %s", dwErr, szRipTest);
return dwErr;
}
//
// create the key for the interface in case it doesn't exist
//
dwErr = RegCreateKeyExW(
hkeyRipTest, g_bind.RIB_Netcard, 0, NULL, 0,
KEY_ALL_ACCESS, NULL, &hkeyIf, &dwCreated
);
RegCloseKey(hkeyRipTest);
if (dwErr != NO_ERROR) {
PRINT3(
"error %d creating subkey %S under registry key %s",
dwErr, g_bind.RIB_Netcard, szRipTest
);
return dwErr;
}
PRINT0("loading options from registry: ");
proend = g_options + (sizeof(g_options) / sizeof(REG_OPTION));
for (pro = g_options; pro < proend; pro++) {
//
// read or initialize the option
//
pro->RO_GetOpt(hkeyIf, pro);
}
RegCloseKey(hkeyIf);
//
// if the defaults were used, give the user a chance to change them
//
if (dwCreated == REG_CREATED_NEW_KEY) {
PRINT0("Default parameters have been written to the registry.");
PRINT2("Please check the key %s\\%S,", szRipTest, g_bind.RIB_Netcard);
PRINT0("modify the values if necessary, and run RIPTEST again.\n");
return ERROR_CAN_NOT_COMPLETE;
}
//
// check the route parameters for errors:
//
// make sure the class of the route is valid
//
dwLowestAddress = g_cfg.RIC_RouteStart;
if (IS_LOOPBACK_ADDR(dwLowestAddress) ||
CLASSD_ADDR(dwLowestAddress) || CLASSE_ADDR(dwLowestAddress)) {
PRINT1(
"ERROR: route %s is of an invalid network class",
INET_NTOA(dwLowestAddress)
);
return ERROR_INVALID_PARAMETER;
}
//
// make sure that from the specified starting address,
// there are enough routes in the network class to generate
// the configured number of routes
//
dwCount = g_cfg.RIC_RouteCount;
dwNetmask = g_cfg.RIC_RouteMask;
dwPrefixLength = PREFIX_LENGTH(dwNetmask);
dwLowestAddress &= dwNetmask;
dwHighestAddress = NTH_ADDRESS(dwLowestAddress, dwPrefixLength, dwCount);
if (IS_LOOPBACK_ADDR(dwHighestAddress) ||
NETCLASS_MASK(dwLowestAddress) != NETCLASS_MASK(dwHighestAddress)) {
PRINT1(
"ERROR: starting route %s is too near the end of its network class",
INET_NTOA(dwLowestAddress)
);
return ERROR_INVALID_PARAMETER;
}
//
// make sure that the authentication type is a supported value
//
if (g_cfg.RIC_AuthType != IPRIP_AUTHTYPE_NONE &&
g_cfg.RIC_AuthType != IPRIP_AUTHTYPE_SIMPLE_PASSWORD) {
PRINT1(
"ERROR: authentication type %d is not supported",
g_cfg.RIC_AuthType
);
return ERROR_INVALID_PARAMETER;
}
//
// make sure the number of packet entries isn't out-of-range
//
if (g_cfg.RIC_PacketEntryCount > 25) {
PRINT1(
"ERROR: packet-enty count %d is too large",
g_cfg.RIC_PacketEntryCount
);
return ERROR_INVALID_PARAMETER;
}
return NO_ERROR;
}
DWORD
RegGetAddress(
HKEY hKey,
PREG_OPTION pOpt
)
{
CHAR szValue[256];
DWORD dwErr, dwType, dwSize;
//
// attempt to read the value
//
dwSize = sizeof(szValue);
dwErr = RegQueryValueEx(
hKey, pOpt->RO_Name, NULL, &dwType, (PBYTE)szValue, &dwSize
);
if (dwErr != NO_ERROR) {
//
// attempt to write the default value to the registry
//
strcpy(szValue, INET_NTOA(*(PDWORD)pOpt->RO_DefVal));
dwSize = strlen(szValue) + 1;
dwType = REG_SZ;
dwErr = RegSetValueEx(
hKey, pOpt->RO_Name, NULL, dwType, (PBYTE)szValue, dwSize
);
}
//
// by now the value in the registry should be in szValue
//
*(PDWORD)pOpt->RO_OptVal = inet_addr(szValue);
PRINT2("%20s == %s", pOpt->RO_Name, szValue);
return dwErr;
}
DWORD
RegGetDWORD(
HKEY hKey,
PREG_OPTION pOpt
)
{
DWORD dwErr, dwValue, dwType, dwSize;
//
// attempt to read the value
//
dwSize = sizeof(DWORD);
dwErr = RegQueryValueEx(
hKey, pOpt->RO_Name, NULL, &dwType, (PBYTE)&dwValue, &dwSize
);
if (dwErr != NO_ERROR) {
//
// attempt to write the default value to the registry
//
dwValue = *(PDWORD)pOpt->RO_DefVal;
dwSize = sizeof(DWORD);
dwType = REG_DWORD;
dwErr = RegSetValueEx(
hKey, pOpt->RO_Name, NULL, dwType, (PBYTE)&dwValue, dwSize
);
}
//
// by now the value in the registry should be in dwValue
//
*(PDWORD)pOpt->RO_OptVal = dwValue;
PRINT2("%20s == %d", pOpt->RO_Name, dwValue);
return dwErr;
}
DWORD
RegGetBinary(
HKEY hKey,
PREG_OPTION pOpt
)
{
PBYTE pValue;
DWORD dwErr, dwType, dwSize;
//
// attempt to read the value
//
dwSize = pOpt->RO_Size;
pValue = (PBYTE)pOpt->RO_OptVal;
dwErr = RegQueryValueEx(
hKey, pOpt->RO_Name, NULL, &dwType, pValue, &dwSize
);
if (dwErr != NO_ERROR) {
//
// attempt to write the default value to the registry
//
pValue = (PBYTE)pOpt->RO_DefVal;
dwSize = pOpt->RO_Size;
dwType = REG_BINARY;
dwErr = RegSetValueEx(
hKey, pOpt->RO_Name, NULL, dwType, pValue, dwSize
);
RtlCopyMemory(pOpt->RO_OptVal, pOpt->RO_DefVal, pOpt->RO_Size);
}
{
PBYTE pb, pbend;
CHAR *psz, szValue[256], szDigits[] = "0123456789ABCDEF";
psz = szValue;
pbend = (PBYTE)pOpt->RO_OptVal + pOpt->RO_Size;
for (pb = (PBYTE)pOpt->RO_OptVal; pb < pbend; pb++) {
*psz++ = szDigits[*pb / 16];
*psz++ = szDigits[*pb % 16];
*psz++ = ':';
}
if (psz != szValue) { --psz; }
*psz = '\0';
PRINT2("%20s == %s", pOpt->RO_Name, szValue);
}
return dwErr;
}
//
// main stress function
//
DWORD
RipTest(
VOID
)
{
SOCKET sock;
SOCKADDR_IN sinaddr;
DWORD dwErr, dwMetric;
IPForwardEntry *ifelist;
LIST_ENTRY rtrlist, *ple;
PRIPTEST_ROUTER_INFO prrs;
InitializeListHead(&rtrlist);
do {
//
// create and set up socket to be used for route transmission
//
dwErr = InitializeSocket(&sock, RIPTEST_PORT);
if (dwErr != NO_ERROR) {
break;
}
//
// transmit single route request on non-RIP port,
// and build a list of responding routers
//
dwErr = DiscoverRouters(sock, &rtrlist);
if (dwErr != NO_ERROR) { closesocket(sock); break; }
//
// generate the list of routes as configured
//
dwErr = GenerateRoutes(&ifelist);
if (dwErr != NO_ERROR) { closesocket(sock); break; }
//
// re-initialize the socket, this time to the RIP port
//
closesocket(sock);
dwErr = InitializeSocket(&sock, IPRIP_PORT);
if (dwErr == SOCKET_ERROR) {
break;
}
for (dwMetric = 8; (INT)dwMetric >= 2; dwMetric -= 3) {
//
// transmit the route table with the specified metric
//
dwErr = TransmitRoutes(sock, dwMetric, ifelist);
//
// give the router time to process the advertisements:
// we allow 30 milliseconds per route, with a minimum of 15 seconds
//
Sleep(max(15000, 30 * g_cfg.RIC_RouteCount));
//
// make connections to Router on each of the responding machines,
// and use MIB api functions to retrieve the route table.
// Verify that the routes transmitted are present,
// and add the servers to the displayed statistics
//
dwErr = VerifyRouteTables(dwMetric, &rtrlist, ifelist);
}
if (g_cfg.RIC_RouteTimeout != 0) {
//
// use timeout to clear routes
//
PRINT1(
"waiting %d milliseconds for routes to timeout",
max(15000, g_cfg.RIC_RouteTimeout * 1000)
);
Sleep(max(15000, g_cfg.RIC_RouteTimeout * 1000));
}
else {
//
// send updates to clean up the routes
//
PRINT0("sending announcements to purge routes advertised");
dwErr = TransmitRoutes(sock, 16, ifelist);
Sleep(max(15000, 30 * g_cfg.RIC_RouteCount));
}
closesocket(sock);
} while(FALSE);
//
// cleanup the server list
//
while (!IsListEmpty(&rtrlist)) {
ple = RemoveHeadList(&rtrlist);
prrs = CONTAINING_RECORD(ple, RIPTEST_ROUTER_INFO, RRS_Link);
HeapFree(GetProcessHeap(), 0, prrs);
}
if (ifelist != NULL) { HeapFree(GetProcessHeap(), 0, ifelist); }
return dwErr;
}
DWORD
InitializeSocket(
SOCKET *psock,
WORD wPort
)
{
SOCKET sock;
DWORD dwErr, dwOption;
//
// create the socket
//
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock == INVALID_SOCKET) {
dwErr = WSAGetLastError();
PRINT1("error %d creating socket", dwErr);
return dwErr;
}
//
// enable address sharing
//
dwOption = 1;
dwErr = setsockopt(
sock,
SOL_SOCKET,
SO_REUSEADDR,
(PCCH)&dwOption,
sizeof(DWORD)
);
if (dwErr == SOCKET_ERROR) {
dwErr = WSAGetLastError();
PRINT1("error %d enabling address re-use on socket", dwErr);
}
//
// enlarge the receive buffer
//
dwOption = g_cfg.RIC_SockBufSize;
dwErr = setsockopt(
sock,
SOL_SOCKET,
SO_RCVBUF,
(PCCH)&dwOption,
sizeof(DWORD)
);
if (dwErr == SOCKET_ERROR) {
dwErr = WSAGetLastError();
PRINT2("error %d enlarging recv buffer to %d bytes", dwErr, dwOption);
}
//
// enlarge the send buffer
//
dwOption = g_cfg.RIC_SockBufSize;
dwErr = setsockopt(
sock,
SOL_SOCKET,
SO_SNDBUF,
(PCCH)&dwOption,
sizeof(DWORD)
);
if (dwErr == SOCKET_ERROR) {
dwErr = WSAGetLastError();
PRINT2("error %d enlarging send buffer to %d bytes", dwErr, dwOption);
}
do {
SOCKADDR_IN sinaddr;
if (g_cfg.RIC_RouteTarget != IPRIP_MULTIADDR) {
//
// enable broadcasting
//
dwOption = 1;
dwErr = setsockopt(
sock,
SOL_SOCKET,
SO_BROADCAST,
(PCCH)&dwOption,
sizeof(DWORD)
);
if (dwErr == SOCKET_ERROR) {
dwErr = WSAGetLastError();
PRINT1("error %d enabling broadcast on socket", dwErr);
break;
}
//
// bind the socket to the RIPTEST port
//
sinaddr.sin_family = AF_INET;
sinaddr.sin_port = htons(wPort);
sinaddr.sin_addr.s_addr = g_bind.RIB_Address;
dwErr = bind(sock, (PSOCKADDR)&sinaddr, sizeof(SOCKADDR_IN));
if (dwErr == SOCKET_ERROR) {
dwErr = WSAGetLastError();
PRINT1("error %d binding socket", dwErr);
break;
}
dwErr = NO_ERROR;
}
else {
struct ip_mreq imOption;
//
// bind to the specified port
//
sinaddr.sin_family = AF_INET;
sinaddr.sin_port = htons(wPort);
sinaddr.sin_addr.s_addr = g_bind.RIB_Address;
dwErr = bind(sock, (PSOCKADDR)&sinaddr, sizeof(SOCKADDR_IN));
if (dwErr == SOCKET_ERROR) {
dwErr = WSAGetLastError();
PRINT1("error %d binding socket", dwErr);
break;
}
//
// set the outgoing interface for multicasts
//
sinaddr.sin_addr.s_addr = g_bind.RIB_Address;
dwErr = setsockopt(
sock,
IPPROTO_IP,
IP_MULTICAST_IF,
(PCCH)&sinaddr.sin_addr,
sizeof(IN_ADDR)
);
if (dwErr == SOCKET_ERROR) {
dwErr = WSAGetLastError();
PRINT1("error %d setting multicast interface", dwErr);
break;
}
//
// join the RIP multicast group
//
imOption.imr_multiaddr.s_addr = IPRIP_MULTIADDR;
imOption.imr_interface.s_addr = g_bind.RIB_Address;
dwErr = setsockopt(
sock,
IPPROTO_IP,
IP_ADD_MEMBERSHIP,
(PCCH)&imOption,
sizeof(struct ip_mreq)
);
if (dwErr == SOCKET_ERROR) {
dwErr = WSAGetLastError();
PRINT1("error %d joining multicast group", dwErr);
break;
}
dwErr = NO_ERROR;
}
} while(FALSE);
if (dwErr != NO_ERROR) { closesocket(sock); }
else { *psock = sock; }
return dwErr;
}
DWORD
DiscoverRouters(
SOCKET sock,
PLIST_ENTRY rtrlist
)
{
INT iLength;
PIPRIP_ENTRY pie;
PIPRIP_HEADER phdr;
SOCKADDR_IN sindest;
DWORD dwErr, dwSize;
PIPRIP_AUTHENT_ENTRY pae;
BYTE pbuf[MAX_PACKET_SIZE];
INT iErr;
FD_SET fs;
TIMEVAL tv;
DWORD dwTicks, dwTicksBefore, dwTicksAfter;
PRINT0("attempting to discover neighboring routers...");
//
// construct the RIP packet
//
phdr = (PIPRIP_HEADER)pbuf;
pie = (PIPRIP_ENTRY)(phdr + 1);
pae = (PIPRIP_AUTHENT_ENTRY)(phdr + 1);
phdr->IH_Command = IPRIP_REQUEST;
phdr->IH_Version = (CHAR)g_cfg.RIC_PacketVersion;
phdr->IH_Reserved = 0;
//
// setup the authentication entry if necessary;
// note that the code allows authentication in RIPv1 packets
//
if (g_cfg.RIC_AuthType == IPRIP_AUTHTYPE_SIMPLE_PASSWORD) {
pae->IAE_AddrFamily = ADDRFAMILY_AUTHENT;
pae->IAE_AuthType = (WORD)g_cfg.RIC_AuthType;
RtlCopyMemory(
pae->IAE_AuthKey,
g_cfg.RIC_AuthKey,
IPRIP_MAX_AUTHKEY_SIZE
);
++pie;
}
//
// setup the single packet entry; we request a meaningless address
//
pie->IE_AddrFamily = htons(AF_INET);
pie->IE_RouteTag = 0;
pie->IE_Destination = 0xccddeeff;
pie->IE_SubnetMask = 0;
pie->IE_Nexthop = 0;
pie->IE_Metric = htonl(IPRIP_INFINITE);
dwSize = (ULONG) ((PBYTE)(pie + 1) - pbuf);
//
// send the route request to the RIP port
//
PRINT1("\tsending REQUEST to %s", INET_NTOA(g_cfg.RIC_RouteTarget));
sindest.sin_family = AF_INET;
sindest.sin_port = htons(IPRIP_PORT);
sindest.sin_addr.s_addr = g_cfg.RIC_RouteTarget;
iLength = sendto(
sock, (PCCH)pbuf, dwSize, 0,
(PSOCKADDR)&sindest, sizeof(SOCKADDR_IN)
);
if (iLength == SOCKET_ERROR || (DWORD)iLength < dwSize) {
dwErr = WSAGetLastError();
PRINT1("error %d sending route request", dwErr);
return dwErr;
}
//
// wait a while before collecting responses
//
Sleep(10000);
//
// repeatedly receive for the next 10 seconds
//
tv.tv_sec = 10;
tv.tv_usec = 0;
//
// this loop executes until 10 seconds have elapsed
//
while (tv.tv_sec > 0) {
FD_ZERO(&fs);
FD_SET(sock, &fs);
//
// get the tick count beofre starting select
//
dwTicksBefore = GetTickCount();
//
// enter the call to select
//
iErr = select(0, &fs, NULL, NULL, &tv);
//
// compute the elapsed time
//
dwTicksAfter = GetTickCount();
if (dwTicksAfter < dwTicksBefore) {
dwTicks = dwTicksAfter + ((DWORD)-1 - dwTicksBefore);
}
else {
dwTicks = dwTicksAfter - dwTicksBefore;
}
//
// update the timeout
//
if (tv.tv_usec < (INT)(dwTicks % 1000) * 1000) {
//
// borrow a second from the tv_sec field
//
--tv.tv_sec;
tv.tv_usec += 1000000;
}
tv.tv_usec -= (dwTicks % 1000) * 1000;
tv.tv_sec -= (dwTicks / 1000);
//
// process any incoming packets there might be
//
if (iErr != 0 && iErr != SOCKET_ERROR && FD_ISSET(sock, &fs)) {
INT addrlen;
SOCKADDR_IN sinsrc;
PRIPTEST_ROUTER_INFO prs;
//
// receive the packet
//
addrlen = sizeof(sinsrc);
iLength = recvfrom(
sock, (PCHAR)pbuf, MAX_PACKET_SIZE, 0,
(PSOCKADDR)&sinsrc, &addrlen
);
if (iLength == 0 || iLength == SOCKET_ERROR) {
dwErr = WSAGetLastError();
PRINT1("error %d receiving packet", dwErr);
continue;
}
//
// create a list entry for the responding router
//
dwErr = CreateRouterStatsEntry(
rtrlist, sinsrc.sin_addr.s_addr, &prs
);
if (dwErr == NO_ERROR) {
PRINT2(
"\treceived RESPONSE from %s (%s)",
INET_NTOA(sinsrc.sin_addr), prs->RRS_DnsName
);
}
}
}
if (rtrlist->Flink == rtrlist) {
PRINT0("\tno neighboring routers discovered");
}
return NO_ERROR;
}
DWORD
GenerateRoutes(
IPForwardEntry **pifelist
)
{
CHAR szAddress[20];
IPForwardEntry *ifelist, *ife;
DWORD dwRouteCount, dwNetworkCount;
DWORD dwStartOffset, dwLowestAddress, dwHighestAddress;
DWORD dw, dwErr, dwAddress, dwNexthop, dwSubnetMask, dwPrefixLength;
dwNexthop = g_cfg.RIC_RouteNexthop;
dwSubnetMask = g_cfg.RIC_RouteMask;
dwPrefixLength = PREFIX_LENGTH(dwSubnetMask);
//
// find the last address in the start-address's network class
//
dwLowestAddress = g_cfg.RIC_RouteStart;
dwHighestAddress =
(CLASSA_ADDR(dwLowestAddress) ? inet_addr("126.255.255.255") :
(CLASSB_ADDR(dwLowestAddress) ? inet_addr("191.255.255.255") :
(CLASSC_ADDR(dwLowestAddress) ? inet_addr("223.255.255.255") : 0)));
//
// figure out how many networks the range can be split into
// using the specified network mask
//
dwLowestAddress &= dwSubnetMask;
dwNetworkCount = ((ntohl(dwHighestAddress) >> (32 - dwPrefixLength)) -
(ntohl(dwLowestAddress) >> (32 - dwPrefixLength)));
//
// choose a starting address for this iteration:
// we have at most K routes, and we are sending n routes,
// so the starting route must be at an offset of between 0 and (K - n)
//
dwRouteCount = g_cfg.RIC_RouteCount;
dwStartOffset = RANDOM(&g_seed, 0, (dwNetworkCount - dwRouteCount));
//
// allocate the array of routes
//
*pifelist =
ifelist = (IPForwardEntry *)HeapAlloc(
GetProcessHeap(), 0,
dwRouteCount * sizeof(IPForwardEntry)
);
if (ifelist == NULL) {
dwErr = GetLastError();
PRINT2(
"error %d allocating %d bytes for route list",
dwErr, dwRouteCount * sizeof(IPForwardEntry)
);
return dwErr;
}
RtlZeroMemory(ifelist, dwRouteCount * sizeof(IPForwardEntry));
//
// fill the table with routes
//
for (dw = dwStartOffset; dw < (dwStartOffset + dwRouteCount); dw++) {
dwAddress = NTH_ADDRESS(dwLowestAddress, dwPrefixLength, dw);
ife = ifelist + (dw - dwStartOffset);
ife->dwForwardDest = dwAddress;
ife->dwForwardMask = dwSubnetMask;
ife->dwForwardNextHop = dwNexthop;
}
return NO_ERROR;
}
DWORD
TransmitRoutes(
SOCKET sock,
DWORD dwMetric,
IPForwardEntry *ifelist
)
{
INT iLength;
WORD wRouteTag;
PIPRIP_HEADER pih;
SOCKADDR_IN sindest;
PIPRIP_ENTRY pie, pistart, piend;
PIPRIP_AUTHENT_ENTRY pae;
IPForwardEntry *ife, *ifend;
BYTE pbuf[2 * MAX_PACKET_SIZE];
DWORD dwErr, dwEntryCount;
//
// setup the message's header
//
pih = (PIPRIP_HEADER)pbuf;
pae = (PIPRIP_AUTHENT_ENTRY)(pih + 1);
pistart = (PIPRIP_ENTRY)(pih + 1);
pih->IH_Command = IPRIP_RESPONSE;
pih->IH_Version = (CHAR)g_cfg.RIC_PacketVersion;
pih->IH_Reserved = 0;
//
// setup the authentication entry if necessary;
// note that the code allows authentication in RIPv1 packets
//
if (g_cfg.RIC_AuthType == IPRIP_AUTHTYPE_SIMPLE_PASSWORD) {
pae->IAE_AddrFamily = ADDRFAMILY_AUTHENT;
pae->IAE_AuthType = (WORD)g_cfg.RIC_AuthType;
RtlCopyMemory(
pae->IAE_AuthKey,
g_cfg.RIC_AuthKey,
IPRIP_MAX_AUTHKEY_SIZE
);
++pistart;
}
//
// pick off the configured number of routes to put in the packet
//
if (g_cfg.RIC_PacketEntryCount != 0) {
dwEntryCount = g_cfg.RIC_PacketEntryCount;
}
else {
//
// choose a random number of entries
//
if (g_cfg.RIC_AuthType == IPRIP_AUTHTYPE_NONE) {
dwEntryCount = RANDOM(&g_seed, 1, 25);
}
else {
dwEntryCount = RANDOM(&g_seed, 1, 24);
}
}
wRouteTag = LOWORD(g_cfg.RIC_RouteTag);
sindest.sin_family = AF_INET;
sindest.sin_port = htons(IPRIP_PORT);
sindest.sin_addr.s_addr = g_cfg.RIC_RouteTarget;
{
DWORD dwCount;
CHAR szDest[20], szFirst[20], szLast[20];
dwCount = g_cfg.RIC_RouteCount;
strcpy(szDest, INET_NTOA(sindest.sin_addr));
strcpy(szFirst, INET_NTOA(ifelist->dwForwardDest));
strcpy(szLast, INET_NTOA((ifelist + dwCount - 1)->dwForwardDest));
PRINT5(
"sending %d routes (%s - %s) to %s using metric %d",
dwCount, szFirst, szLast, szDest, dwMetric
);
}
//
// loop filling the buffer with packets and sending it when its full
//
piend = pistart + dwEntryCount;
ifend = ifelist + g_cfg.RIC_RouteCount;
for (ife = ifelist, pie = pistart; ife < ifend; ife++, pie++) {
//
// send the current buffer if it is full
//
if (pie >= piend) {
//
// sleep for the specified packet-gap
//
Sleep(g_cfg.RIC_PacketGap);
iLength = sendto(
sock, (PCCH)pbuf, (ULONG)((PBYTE)pie - pbuf), 0,
(PSOCKADDR)&sindest, sizeof(SOCKADDR_IN)
);
if (iLength == SOCKET_ERROR || iLength < ((PBYTE)piend - pbuf)) {
dwErr = WSAGetLastError();
PRINT2(
"error %d sending packet to %s",
dwErr, INET_NTOA(sindest.sin_addr)
);
}
if (g_cfg.RIC_PacketEntryCount != 0) {
dwEntryCount = g_cfg.RIC_PacketEntryCount;
}
else {
//
// choose a random number of entries
//
if (g_cfg.RIC_AuthType == IPRIP_AUTHTYPE_NONE) {
dwEntryCount = RANDOM(&g_seed, 1, 25);
}
else {
dwEntryCount = RANDOM(&g_seed, 1, 24);
}
}
piend = pistart + dwEntryCount;
pie = pistart;
}
//
// add another entry
//
pie->IE_AddrFamily = htons(AF_INET);
pie->IE_Destination = ife->dwForwardDest;
pie->IE_Metric = htonl(dwMetric);
pie->IE_RouteTag = htons(wRouteTag);
pie->IE_Nexthop = ife->dwForwardNextHop;
pie->IE_SubnetMask = ife->dwForwardMask;
}
//
// if there is anything left, send it
//
if (pie > pistart) {
iLength = sendto(
sock, (PCCH)pbuf, (ULONG)((PBYTE)pie - pbuf), 0,
(PSOCKADDR)&sindest, sizeof(SOCKADDR_IN)
);
}
return NO_ERROR;
}
DWORD
VerifyRouteTables(
DWORD dwMetric,
PLIST_ENTRY rtrlist,
IPForwardEntry *ifelist
)
{
PLIST_ENTRY ple;
MIB_OPAQUE_QUERY roq;
MIB_OPAQUE_INFO *proi;
WCHAR pwsRouter[256];
MIB_SERVER_HANDLE hRouter;
PRIPTEST_ROUTER_INFO prrs;
MIB_IPFORWARDTABLE *ifrlist;
IPForwardEntry *ife, *ifend;
MIB_IPFORWARDROW *ifr, *ifrend;
DWORD dwInvalidMetrics, dwRoutesMissing;
DWORD dwErr, dwNumEntries, dwInSize, dwOutSize;
//
// go through the list of routers, connecting to the Router
// on each machine and querying its routing table
//
for (ple = rtrlist->Flink; ple != rtrlist; ple = ple->Flink) {
prrs = CONTAINING_RECORD(ple, RIPTEST_ROUTER_INFO, RRS_Link);
PRINT1("-----STATS FOR %s-----", prrs->RRS_DnsName);
//
// initialize the query arguments
//
mbstowcs(pwsRouter, prrs->RRS_DnsName, strlen(prrs->RRS_DnsName) + 1);
roq.dwVarId = IP_FORWARDTABLE;
dwInSize = sizeof(MIB_OPAQUE_QUERY) - sizeof(DWORD);
proi = NULL;
dwOutSize = 0;
//
// perform the query
//
dwErr = MprAdminMIBServerConnect(pwsRouter, &hRouter);
if (dwErr != NO_ERROR) {
continue;
}
dwErr = MprAdminMIBEntryGet(
hRouter, PID_IP, IPRTRMGR_PID,
(PVOID)&roq, dwInSize, (PVOID *)&proi, &dwOutSize
);
if (dwErr != NO_ERROR) {
PRINT2(
"error %d querying route table on server %s",
dwErr, prrs->RRS_DnsName
);
MprAdminMIBServerDisconnect(hRouter);
continue;
}
else
if (proi == NULL) {
PRINT1(
"empty route table retrieved from server %s",
prrs->RRS_DnsName
);
MprAdminMIBServerDisconnect(hRouter);
continue;
}
//
// look through the table of routes retrieved,
// to verify thats the routes advertised are among them
//
dwRoutesMissing = 0;
dwInvalidMetrics = 0;
ifrlist = (PMIB_IPFORWARDTABLE)(proi->rgbyData);
dwNumEntries = ifrlist->dwNumEntries;
ifend = ifelist + g_cfg.RIC_RouteCount;
for (ife = ifelist; ife < ifend; ife++) {
//
// each time we find an advertised route,
// we swap it to the end of the table;
// thus, the size of the table that we need to search
// decreases with the number of routes we have found
//
ifrend = ifrlist->table + dwNumEntries;
for (ifr = ifrlist->table; ifr < ifrend; ifr++) {
if (ife->dwForwardDest == ifr->dwForwardDest) {
if (ifr->dwForwardMetric1 == (dwMetric + 1)) {
ife->dwForwardMetric5 = ROUTE_STATUS_OK;
}
else {
//
// set the status for this route
//
++dwInvalidMetrics;
ife->dwForwardMetric5 = ROUTE_STATUS_METRIC;
PRINT3(
"\troute to %s has metric %d, expected %d",
INET_NTOA(ife->dwForwardDest),
ife->dwForwardMetric1, dwMetric + 1
);
}
//
// overwrite with the item at the end of the table;
// if we are at the end of the table, do nothing
//
if (ifr != (ifrend - 1)) { *ifr = *(ifrend - 1); }
--dwNumEntries;
break;
}
}
//
// if the item wasn't found, mark it as such
//
if (ifr >= ifrend) {
++dwRoutesMissing;
ife->dwForwardMetric5 = ROUTE_STATUS_MISSING;
PRINT1("\troute to %s missing", INET_NTOA(ife->dwForwardDest));
}
}
MprAdminMIBBufferFree(proi);
MprAdminMIBServerDisconnect(hRouter);
PRINT2("%20s == %d", "routes missing", dwRoutesMissing);
PRINT2("%20s == %d", "invalid metrics", dwInvalidMetrics);
}
return NO_ERROR;
}
DWORD
CreateRouterStatsEntry(
PLIST_ENTRY rtrlist,
DWORD dwAddress,
PRIPTEST_ROUTER_INFO *pprrs
)
{
DWORD dwErr;
PHOSTENT phe;
PRIPTEST_ROUTER_INFO prrs;
phe = gethostbyaddr((const char *)&dwAddress, sizeof(DWORD), PF_INET);
if (phe == NULL) {
dwErr = WSAGetLastError();
PRINT2(
"error %d retrieving name for host %s", dwErr, INET_NTOA(dwAddress)
);
return dwErr;
}
prrs = (PRIPTEST_ROUTER_INFO)HeapAlloc(
GetProcessHeap(), 0,
sizeof(RIPTEST_ROUTER_INFO)
);
if (prrs == NULL) {
dwErr = GetLastError();
PRINT2(
"error %d allocating %d bytes for router stats",
dwErr, sizeof(RIPTEST_ROUTER_INFO)
);
return dwErr;
}
RtlZeroMemory(prrs, sizeof(RIPTEST_ROUTER_INFO));
prrs->RRS_Address = dwAddress;
strcpy(prrs->RRS_DnsName, phe->h_name);
InsertHeadList(rtrlist, &prrs->RRS_Link);
if (pprrs != NULL) { *pprrs = prrs; }
return NO_ERROR;
}
DWORD
PrintUsage(
VOID
)
{
printf("usage: riptest [adapter_guid]");
printf("\n\te.g. riptest {73C2D5F0-A352-11D1-9043-0060089FC48B}\n");
printf("\n\tThe first time RIPTEST is run, it sets up the registry");
printf("\n\twith defaults for the specified adapter.");
printf("\n");
return NO_ERROR;
}
} // end extern "C"
Reference in a new issue Copy permalink