|
|
/*
File: Rip.c
Performs an upgrade of ip rip to nt5 router by munging registry values.
Paul Mayfield, 9/3/97
The following steps are neccessary to upgrade rip: Params = HKLM/SYS/CCS/Services/IpRip/Parameters 1. Get the global info block for IP w/ MprConfigTransportGetInfo - Add a IPRIP_GLOBAL_CONFIG (ipriprm.h) block initialized as in routemon (rip.c, protocol.c) - Type is MS_IP_RIP as in sdk/inc/ipinfoid.h - Mappings Params.LoggingLevel to this global config blob
2. Get Interface info for each ras or lan ip interface - Add an IPRIP_IF_CONFIG (ipriprm.h) block (type MS_IP_RIP) - Initialize as per routemon - Mappings Params.AcceptHostRoutes - IC_ProtocolFlags (0=disable,1=enable) Params.UpdateFreq...=FullUpdateInterval Params.*Timeouts=
3. "SilentRip" param rules - If wks->srv, ignore this and set announce to disabled. accept=rip1 - If srv->srv, map announce to this value. accept=rip1
IP Rip Parameter Mapping ========================
Rip Listener IpRip in Router RIP_PARAMETERS IPRIP_IF_CONFIG ============== =============== "SilentRIP" IC_AcceptMode,IC_AnnounceMode "AcceptHostRoutes" IC_ProtocolFlags "AnnounceHostRoutes" IC_ProtocolFlags "AcceptDefaultRoutes" IC_ProtocolFlags "AnnounceDefaultRoutes" IC_ProtocolFlags "EnableSplitHorizon" IC_ProtocolFlags "EnablePoisonedReverse" IC_ProtocolFlags "RouteTimeout" IC_RouteExpirationInterval "GarbageTimeout" IC_RouteRemovalInterval "UpdateFrequency" IC_FullUpdateInterval "EnableTriggeredUpdates" IC_ProtocolFlags "MaxTriggeredUpdateFrequency" NOT MIGRATED "OverwriteStaticRoutes" IC_ProtocolFlags
IpRip in Router IPRIP_GLOBAL_CONFIG =============== "LoggingLevel" GC_LoggingLevel REGVAL_ACCEPT_HOST "AcceptHostRoutes" REGVAL_ANNOUNCE_HOST "AnnounceHostRoutes" REGVAL_ACCEPT_DEFAULT "AcceptDefaultRoutes" REGVAL_ANNOUNCE_DEFAULT "AnnounceDefaultRoutes" REGVAL_SPLITHORIZON "EnableSplitHorizon" REGVAL_POISONREVERSE "EnablePoisonedReverse" REGVAL_LOGGINGLEVEL "LoggingLevel" REGVAL_ROUTETIMEOUT "RouteTimeout" REGVAL_GARBAGETIMEOUT "GarbageTimeout" REGVAL_UPDATEFREQUENCY "UpdateFrequency" REGVAL_TRIGGEREDUPDATES "EnableTriggeredUpdates" REGVAL_TRIGGERFREQUENCY "MaxTriggeredUpdateFrequency" REGVAL_OVERWRITESTATIC "OverwriteStaticRoutes"*/
#include "upgrade.h"
#include <ipriprm.h>
#include <routprot.h>
#include <mprapi.h>
// Definition of table that migrates rip parameters
typedef struct _PARAM_TO_FLAG { PWCHAR pszParam; DWORD dwFlag;} PARAM_TO_FLAG;
// Definition of user data passed to interface enumeration
// callback
typedef struct _RIP_IF_DATA { IPRIP_IF_CONFIG * pLanConfig; IPRIP_IF_CONFIG * pWanConfig;} RIP_IF_DATA;
// Types of upgrade
#define SRV_TO_SRV 0
#define WKS_TO_SRV 1
// Globals
static const WCHAR szTempKey[] = L"DeleteMe";static HKEY hkRouter = NULL;static HKEY hkTemp = NULL;
PARAM_TO_FLAG ParamFlagTable[] = { {L"AcceptHostRoutes", IPRIP_FLAG_ACCEPT_HOST_ROUTES}, {L"AnnounceHostRoutes", IPRIP_FLAG_ANNOUNCE_HOST_ROUTES}, {L"AcceptDefaultRoutes", IPRIP_FLAG_ACCEPT_DEFAULT_ROUTES}, {L"AnnounceDefaultRoutes", IPRIP_FLAG_ANNOUNCE_DEFAULT_ROUTES}, {L"EnableSplitHorizon", IPRIP_FLAG_SPLIT_HORIZON}, {L"EnablePoisonedReverse", IPRIP_FLAG_POISON_REVERSE}, {L"EnableTriggeredUpdates", IPRIP_FLAG_TRIGGERED_UPDATES}, {L"OverwriteStaticRoutes", IPRIP_FLAG_OVERWRITE_STATIC_ROUTES}, {NULL, 0}};
// Restore the registry from from
// backup and make sure all global handles are opened
DWORD IpRipPrepareRegistry( IN PWCHAR BackupFileName) { DWORD dwErr,dwDisposition;
// Get access to the router registry key
dwErr = UtlAccessRouterKey(&hkRouter); if (dwErr != ERROR_SUCCESS) { PrintMessage(L"Unable to access router key.\n"); return dwErr; }
// Restore the rip parameters from backup
__try { // Open up the temporary key
dwErr = RegCreateKeyEx( hkRouter, szTempKey, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkTemp, &dwDisposition); if (dwErr!=ERROR_SUCCESS) return dwErr;
// Restore the saved registry information to
// the temp key
UtlSetupRestorePrivilege(TRUE); dwErr = RegRestoreKeyW( hkTemp, BackupFileName, 0); if (dwErr != ERROR_SUCCESS) return dwErr; } __finally { UtlSetupRestorePrivilege(FALSE); } return NO_ERROR;}
// Function initializes the rip global information based
// on the parameters saved from the iprip service.
//
// 1. Get the global info block for IP w/ MprConfigTransportGetInfo
// - Add a IPRIP_GLOBAL_CONFIG (ipriprm.h)
// block initialized as in routemon (rip.c, protocol.c)
// - Type is MS_IP_RIP as in sdk/inc/ipinfoid.h
// - Mappings
// Params.LoggingLevel to this global config blob
DWORD IpRipUpgradeGlobalInfo( IN dwt * RipParams) { DWORD dwErr, dwTransSize, dwVal, dwNewSize = 0; LPBYTE lpTransInfo=NULL, lpNewTransInfo=NULL; HANDLE hSvrConfig=NULL, hTransport=NULL; // Create/initialize an IPRIP_GLOBAL_CONFIG block
IPRIP_GLOBAL_CONFIG RipGlobalConfig = { IPRIP_LOGGING_ERROR, // Logging level
1024 * 1024, // Max recv-queue size
1024 * 1024, // Max send-queue size
5, // Minimum triggered-update interval
IPRIP_FILTER_DISABLED, // Peer-filter mode
0 // Peer-filter count
};
// Reset any values read from the previous iprip configuration
dwErr = dwtGetValue( RipParams, L"LoggingLevel", &dwVal); if (dwErr == NO_ERROR) RipGlobalConfig.GC_LoggingLevel=dwVal;
__try { // Add the rip global config to ip's global config
dwErr = MprConfigServerConnect( NULL, &hSvrConfig); if (dwErr != NO_ERROR) return dwErr;
dwErr = MprConfigTransportGetHandle( hSvrConfig, PID_IP, &hTransport); if (dwErr != NO_ERROR) return dwErr;
dwErr = MprConfigTransportGetInfo( hSvrConfig, hTransport, &lpTransInfo, &dwTransSize, NULL, NULL, NULL); if (dwErr != NO_ERROR) return dwErr;
dwErr = UtlUpdateInfoBlock( TRUE, lpTransInfo, MS_IP_RIP, sizeof(IPRIP_GLOBAL_CONFIG), 1, (LPBYTE)&RipGlobalConfig, &lpNewTransInfo, &dwNewSize); if (dwErr != NO_ERROR) return dwErr;
// Commit the information
dwErr = MprConfigTransportSetInfo( hSvrConfig, hTransport, lpNewTransInfo, dwNewSize, NULL, 0, NULL); if (dwErr != NO_ERROR) return NO_ERROR; } __finally { if (lpTransInfo) MprConfigBufferFree(lpTransInfo); if (lpNewTransInfo) MprConfigBufferFree(lpNewTransInfo); if (hSvrConfig) MprConfigServerDisconnect(hSvrConfig); }
return NO_ERROR;}
// Returns whether this is a wks->srv or srv->srv upgrade
DWORD IpRipGetUpgradeType() { return SRV_TO_SRV;}
// Migrates the silent rip parameter.
// 3. "SilentRip" param rules
// - If wks->srv, announce=disabled, accept=rip1
// - If srv->srv, announce=SilentRip, accept=rip1
DWORD IpRipMigrateRipSilence( IN OUT IPRIP_IF_CONFIG * RipIfConfig, IN DWORD dwSilence, IN BOOL IsWan) { DWORD UpgradeType = IpRipGetUpgradeType(); if (IsWan) { if (UpgradeType == WKS_TO_SRV) { RipIfConfig->IC_AcceptMode = IPRIP_ACCEPT_RIP1_COMPAT; RipIfConfig->IC_AnnounceMode = IPRIP_ACCEPT_DISABLED; } else if (UpgradeType == SRV_TO_SRV) { RipIfConfig->IC_AcceptMode = IPRIP_ACCEPT_RIP1_COMPAT; RipIfConfig->IC_AnnounceMode = dwSilence; } } else { if (UpgradeType == WKS_TO_SRV) { RipIfConfig->IC_AcceptMode = IPRIP_ACCEPT_RIP1; RipIfConfig->IC_AnnounceMode = IPRIP_ACCEPT_DISABLED; } else if (UpgradeType == SRV_TO_SRV) { RipIfConfig->IC_AcceptMode = IPRIP_ACCEPT_RIP1; RipIfConfig->IC_AnnounceMode = dwSilence; } }
return NO_ERROR;}
DWORD IpRipSetParamFlag( IN dwt * RipParams, IN PWCHAR ValName, IN DWORD dwFlag, OUT DWORD * dwParam) { DWORD dwVal, dwErr;
dwErr = dwtGetValue(RipParams, ValName, &dwVal); if (dwErr == NO_ERROR) { if (dwVal) *dwParam |= dwFlag; else *dwParam &= ~dwFlag; }
return NO_ERROR;}
// Update the lan interface parameters from previous config
DWORD IpRipUpdateIfConfig( IN dwt * RipParams, OUT IPRIP_IF_CONFIG * RipIfConfig, IN BOOL IsWan) { DWORD dwErr, dwVal; PARAM_TO_FLAG * pCurFlag;
// Loop through all the parameter mappings,
// setting the appripriate flag in the rip config
pCurFlag = &(ParamFlagTable[0]); while (pCurFlag->pszParam) { // Set the flag as appropriate
IpRipSetParamFlag( RipParams, pCurFlag->pszParam, pCurFlag->dwFlag, &(RipIfConfig->IC_ProtocolFlags));
// Increment the enumeration
pCurFlag++; }
// Set the parameters migrated as parameters
dwErr = dwtGetValue(RipParams, L"UpdateFrequency", &dwVal); if (dwErr == NO_ERROR) RipIfConfig->IC_FullUpdateInterval = dwVal; dwErr = dwtGetValue(RipParams, L"RouteTimeout", &dwVal); if (dwErr == NO_ERROR) RipIfConfig->IC_RouteExpirationInterval = dwVal; dwErr = dwtGetValue(RipParams, L"GarbageTimeout", &dwVal); if (dwErr == NO_ERROR) RipIfConfig->IC_RouteRemovalInterval = dwVal;
// Upgrade the silence parameter
dwErr = dwtGetValue(RipParams, L"SilentRIP", &dwVal); if (dwErr == NO_ERROR) IpRipMigrateRipSilence(RipIfConfig, dwVal, IsWan);
return NO_ERROR;}
//
// Callback function takes an interface and updates
// its rip configuration.
//
// Returns TRUE to continue the enumerate, FALSE to
// stop it
//
DWORD IpRipUpgradeInterface( IN HANDLE hConfig, IN MPR_INTERFACE_0 * pIf, IN HANDLE hUserData){ RIP_IF_DATA * pData = (RIP_IF_DATA*)hUserData; IPRIP_IF_CONFIG * pConfig; HANDLE hTransport = NULL; LPBYTE pTransInfo=NULL, pNewTransInfo=NULL; DWORD dwErr, dwIfSize, dwNewTransSize = 0;
// Validate lan and wan interfaces
if ((hConfig == NULL) || (pIf == NULL) || (pData == NULL)) { return FALSE; }
// Is this a LAN or a WAN interface
if (pIf->dwIfType == ROUTER_IF_TYPE_DEDICATED) pConfig = pData->pLanConfig; else if (pIf->dwIfType == ROUTER_IF_TYPE_HOME_ROUTER || pIf->dwIfType == ROUTER_IF_TYPE_FULL_ROUTER) pConfig = pData->pWanConfig; else return TRUE;
do { // Get the handle to ip info associated with this if
dwErr = MprConfigInterfaceTransportGetHandle( hConfig, pIf->hInterface, PID_IP, &hTransport); if (dwErr != NO_ERROR) break;
// Get the ip info associated with this if
dwErr = MprConfigInterfaceTransportGetInfo( hConfig, pIf->hInterface, hTransport, &pTransInfo, &dwIfSize); if (dwErr != NO_ERROR) break;
// Update the info block with the rip data
dwErr = UtlUpdateInfoBlock ( TRUE, pTransInfo, MS_IP_RIP, sizeof(IPRIP_IF_CONFIG), 1, (LPBYTE)pConfig, &pNewTransInfo, &dwNewTransSize); if (dwErr != NO_ERROR) break;
// Commit the change
dwErr = MprConfigInterfaceTransportSetInfo( hConfig, pIf->hInterface, hTransport, pNewTransInfo, dwNewTransSize); if (dwErr != NO_ERROR) break; } while (FALSE);
// Cleanup
{ if (pNewTransInfo) MprConfigBufferFree(pNewTransInfo); if (pTransInfo) MprConfigBufferFree(pTransInfo); }
return TRUE;}
// Initializes the rip per-interface information based on the
// parameters saved from the iprip service.
//
// 2. Get Interface info for each ras or lan ip interface
// - Add an IPRIP_IF_CONFIG (ipriprm.h) block (type MS_IP_RIP)
// - Initialize as per routemon
// - Mappings
// Params.AcceptHostRoutes - IC_ProtocolFlags (0=disable,1=enable)
// Params.UpdateFreq...=FullUpdateInterval
// Params.*Timeouts=
DWORD IpRipUpgradeInterfaces( IN dwt * RipParams) { DWORD dwErr; // Create/initialize an rip info blocks
IPRIP_IF_CONFIG RipLanConfig = { 0, // State (read-only)
1, // Metric
IPRIP_UPDATE_PERIODIC, // Update mode
IPRIP_ACCEPT_RIP1, // Accept mode
IPRIP_ANNOUNCE_RIP1, // Announce mode
IPRIP_FLAG_SPLIT_HORIZON | IPRIP_FLAG_POISON_REVERSE | IPRIP_FLAG_GRACEFUL_SHUTDOWN | IPRIP_FLAG_TRIGGERED_UPDATES, // Protocol flags
180, // Route-expiration interval
120, // Route-removal interval
30, // Full-update interval
IPRIP_AUTHTYPE_NONE, // Authentication type
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, // Authentication key
0, // Route tag
IPRIP_PEER_DISABLED, // Unicast-peer mode
IPRIP_FILTER_DISABLED, // Accept-filter mode
IPRIP_FILTER_DISABLED, // Announce-filter mode
0, // Unicast-peer count
0, // Accept-filter count
0 // Announce-filter count
}; IPRIP_IF_CONFIG RipWanConfig = { 0, 1, IPRIP_UPDATE_DEMAND, // Update mode for WAN
IPRIP_ACCEPT_RIP1, IPRIP_ANNOUNCE_RIP1, IPRIP_FLAG_SPLIT_HORIZON | IPRIP_FLAG_POISON_REVERSE | IPRIP_FLAG_GRACEFUL_SHUTDOWN, 180, 120, 30, IPRIP_AUTHTYPE_NONE, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, 0, IPRIP_PEER_DISABLED, IPRIP_FILTER_DISABLED, IPRIP_FILTER_DISABLED, 0, 0, 0 };
RIP_IF_DATA RipBlobs = { &RipLanConfig, &RipWanConfig };
// Update the lan config blob with values from previous
// installation of rip service.
dwErr = IpRipUpdateIfConfig(RipParams, RipBlobs.pLanConfig, FALSE); if (dwErr != NO_ERROR) return dwErr; // Update the wan config blob with values from previous
// installation of rip service.
dwErr = IpRipUpdateIfConfig(RipParams, RipBlobs.pWanConfig, TRUE); if (dwErr != NO_ERROR) return dwErr;
// Enumerate the interfaces, updating each one with
// rip config as you go.
dwErr = UtlEnumerateInterfaces( IpRipUpgradeInterface, &RipBlobs); if (dwErr != NO_ERROR) return dwErr; return NO_ERROR;}
// Restores the Rip parameters that were saved before upgrade.
// This function assumes that those parameters are being stored
// temporarily in hkTemp
DWORD IpRipMigrateParams() { DWORD dwErr, dwVal; dwt RipParams;
__try { // Load in the parameters that were set for Rip
dwErr = dwtLoadRegistyTable(&RipParams, hkTemp); if (dwErr != NO_ERROR) return dwErr;
// Migrate the various types of paramters
dwErr = IpRipUpgradeGlobalInfo(&RipParams); if (dwErr != NO_ERROR) return dwErr;
// Migrate the per-interface parameters
dwErr = IpRipUpgradeInterfaces(&RipParams); if (dwErr != NO_ERROR) return dwErr; } __finally { dwtCleanup(&RipParams); }
return NO_ERROR;}
// Cleanup the work done in the registry
DWORD IpRipCleanupRegistry() { if (hkTemp) RegCloseKey(hkTemp); if (hkRouter) { RegDeleteKey(hkRouter, szTempKey); RegCloseKey(hkRouter); } hkTemp = NULL; hkRouter = NULL; return NO_ERROR;}
// Upgrades iprip to nt 5.0 router
DWORD IpRipToRouterUpgrade( IN PWCHAR FileName) { DWORD dwErr;
__try { // Restore the registry from the backup file
dwErr = IpRipPrepareRegistry(FileName); if (dwErr != NO_ERROR) return dwErr;
// Migrate rip's parameters to the appropriate
// new locations
dwErr = IpRipMigrateParams(); if (dwErr != NO_ERROR) return dwErr;
// Mark the computer as having been configured
//
dwErr = UtlMarkRouterConfigured(); if (dwErr != NO_ERROR) { PrintMessage(L"Unable to mark router as configured.\n"); return dwErr; } } __finally { IpRipCleanupRegistry(); }
return NO_ERROR;}
|
