|
|
#include "precomp.h"
WCHAR g_wszRtrMgrDLL[] = L"%SystemRoot%\\system32\\IPRTRMGR.DLL";DWORD g_dwIfState = MIB_IF_ADMIN_STATUS_UP;BOOL g_bDiscEnable = FALSE;
#define IP_KEY L"Ip"
#undef EXTRA_DEBUG
DWORDValidateInterfaceInfo( IN LPCWSTR pwszIfName, OUT RTR_INFO_BLOCK_HEADER **ppInfo, OPTIONAL OUT PDWORD pdwIfType, OPTIONAL OUT INTERFACE_STORE **ppIfStore OPTIONAL ){ PRTR_INFO_BLOCK_HEADER pOldInfo = NULL; DWORD dwErr, dwIfType, dwTmpSize; BOOL bFound = FALSE; LIST_ENTRY *ple; PINTERFACE_STORE pii;
if(ppInfo) { *ppInfo = NULL; }
if(ppIfStore) { *ppIfStore = NULL; } //
// If the current mode is commit, get info from config/router
//
if(g_bCommit) { dwErr = GetInterfaceInfo(pwszIfName, ppInfo, NULL, pdwIfType);
return dwErr; }
//
// Uncommit mode. Try to find the interface in the list
//
bFound = FALSE; for(ple = g_leIfListHead.Flink; ple != &g_leIfListHead; ple = ple->Flink) { pii = CONTAINING_RECORD(ple, INTERFACE_STORE, le); if (_wcsicmp(pii->pwszIfName, pwszIfName) == 0) { bFound = TRUE; break; } } if(!bFound || !pii->bValid) { //
// the required one was not found, or it was not valid
// Need to get the info for both cases
//
dwErr = GetInterfaceInfo(pwszIfName, &pOldInfo, NULL, &dwIfType); if (dwErr isnot NO_ERROR) { return dwErr; } } if(bFound) { if(!pii->bValid) { //
// Update
//
pii->pibhInfo = pOldInfo; pii->bValid = TRUE; pii->dwIfType = dwIfType; } } else { //
// No entry for the interface in the list.
//
pii = HeapAlloc(GetProcessHeap(), 0, sizeof(INTERFACE_STORE)); if(pii == NULL) { FREE_BUFFER(pOldInfo); DisplayMessage(g_hModule, MSG_IP_NOT_ENOUGH_MEMORY ); return ERROR_NOT_ENOUGH_MEMORY; } pii->pwszIfName = HeapAlloc(GetProcessHeap(), 0, (wcslen(pwszIfName) + 1) * sizeof(WCHAR)); if(pii->pwszIfName == NULL) { FREE_BUFFER(pOldInfo); HeapFree(GetProcessHeap(), 0, pii); DisplayMessage(g_hModule, MSG_IP_NOT_ENOUGH_MEMORY ); return ERROR_NOT_ENOUGH_MEMORY; } InsertHeadList(&g_leIfListHead, &(pii->le)); wcscpy(pii->pwszIfName, pwszIfName); pii->pibhInfo = pOldInfo; pii->bValid = TRUE; pii->dwIfType = dwIfType; }
if(ppIfStore) { *ppIfStore = pii; }
if(pdwIfType) { *pdwIfType = pii->dwIfType; }
if(ppInfo) { *ppInfo = pii->pibhInfo; }
return NO_ERROR;}
DWORDValidateGlobalInfo( OUT RTR_INFO_BLOCK_HEADER **ppInfo ){ DWORD dwErr; //
// If the current mode is commit, get info from config/router
//
if(g_bCommit) { dwErr = GetGlobalInfo(ppInfo);
return dwErr; }
//
// Uncommit mode. Check if the info in g_tiTransport is valid
//
if(g_tiTransport.bValid) { *ppInfo = g_tiTransport.pibhInfo; } else { //
// Get the info from config/router and store in g_tiTransport
// Mark the info to be valid.
//
dwErr = GetGlobalInfo(ppInfo); if (dwErr isnot NO_ERROR) { return dwErr; }
g_tiTransport.pibhInfo = *ppInfo; g_tiTransport.bValid = TRUE; }
return NO_ERROR;}
DWORDGetGlobalInfo( OUT PRTR_INFO_BLOCK_HEADER *ppibhInfo )
/*++
Routine Description:
Gets global transport information from registry or router.
Arguments:
bMprConfig - Info from Registry or info from router ppibhInfo - ptr to header Return Value:
NO_ERROR, ERROR_INVALID_PARAMETER, ERROR_ROUTER_STOPPED --*/
{
HANDLE hTransport = (HANDLE) NULL; DWORD dwRes, dwSize; PRTR_INFO_BLOCK_HEADER pibhInfo = (PRTR_INFO_BLOCK_HEADER ) NULL; if(ppibhInfo == NULL) { return ERROR_INVALID_PARAMETER; }
do {
#ifdef READROUTERINFO
if (IsRouterRunning()) { //
// Retrieve global protocol information from router
//
dwRes = MprAdminTransportGetInfo(g_hMprAdmin, PID_IP, (LPBYTE*) &pibhInfo, &dwSize, NULL, NULL);
if ( dwRes != NO_ERROR ) { break; } if ( pibhInfo == (PRTR_INFO_BLOCK_HEADER) NULL ) { dwRes = ERROR_INVALID_PARAMETER; break; }
//
// unfortunately, the memory allocation mechanisms
// are different between the apis that access the registry
// and those that access that the running router. To make
// the source of the info transparent to the caller, we
// need to copy this info out.
//
*ppibhInfo = HeapAlloc(GetProcessHeap(), 0, dwSize);
if ( *ppibhInfo == NULL) { dwRes = GetLastError();
break; }
CopyMemory(*ppibhInfo, pibhInfo, dwSize);
MprAdminBufferFree(pibhInfo); } else#endif
{#ifdef READROUTERINFO
//
// Router not running, get info from the registry
//
#else
//
// Always get the information from the registry.
// Doesn't matter if the router is running or not.
// When setting the global information,
// write it to registry and to the router (if it is running).
//
#endif
dwRes = MprConfigTransportGetHandle(g_hMprConfig, PID_IP, &hTransport);
if ( dwRes != NO_ERROR ) { break; }
dwRes = MprConfigTransportGetInfo(g_hMprConfig, hTransport, (LPBYTE*) &pibhInfo, &dwSize, NULL, NULL, NULL);
if ( dwRes != NO_ERROR ) { break; }
if(( pibhInfo == (PRTR_INFO_BLOCK_HEADER) NULL ) or (dwSize < sizeof(RTR_INFO_BLOCK_HEADER))) { dwRes = ERROR_TRANSPORT_NOT_PRESENT; break; }
//
// HACKHACK: we know that MprConfigXxx apis allocate from
// process heap, so we can return the same block
//
*ppibhInfo = pibhInfo; } } while(FALSE);
return dwRes;}
DWORDSetGlobalInfo( IN PRTR_INFO_BLOCK_HEADER pibhInfo )
/*++
Routine Description:
Sets global transport information to both the registry and the router
Arguments:
pibhInfo - ptr to header Return Value:
NO_ERROR, ERROR_ROUTER_STOPPED --*/
{ DWORD dwARes = NO_ERROR, dwCRes = NO_ERROR; HANDLE hTransport; UINT i; PRTR_INFO_BLOCK_HEADER pibhNewInfo, pibhOldInfo;
//
// Create a new info block with all 0-length blocks removed
// since we don't want to write them to the registry,
// we only need to send them to the router which we
// will do with the original info block below.
//
pibhOldInfo = NULL; pibhNewInfo = pibhInfo;
for (i=0; (dwCRes is NO_ERROR) && (i<pibhInfo->TocEntriesCount); i++) { if (pibhInfo->TocEntry[i].InfoSize is 0) { pibhOldInfo = pibhNewInfo;
dwCRes = MprInfoBlockRemove(pibhOldInfo, pibhOldInfo->TocEntry[i].InfoType, &pibhNewInfo);
if (pibhOldInfo isnot pibhInfo) { FREE_BUFFER(pibhOldInfo); } } }
if (dwCRes is NO_ERROR) { dwCRes = MprConfigTransportGetHandle(g_hMprConfig, PID_IP, &hTransport); }
if (dwCRes is NO_ERROR) { dwCRes = MprConfigTransportSetInfo(g_hMprConfig, hTransport, (LPBYTE) pibhNewInfo, pibhNewInfo->Size, NULL, 0, NULL); }
if (pibhNewInfo isnot pibhInfo) { FREE_BUFFER(pibhNewInfo); }
//
// Even if we failed to write to the registry, we still want
// to write to the router.
//
// We use the original format when writing to the router, since it
// needs to see the 0-length blocks in order to delete config info.
//
if(IsRouterRunning()) { dwARes = MprAdminTransportSetInfo(g_hMprAdmin, PID_IP, (LPBYTE) pibhInfo, pibhInfo->Size, NULL, 0);
}
return (dwARes isnot NO_ERROR)? dwARes : dwCRes;}
DWORDGetInterfaceInfo( IN LPCWSTR pwszIfName, OUT RTR_INFO_BLOCK_HEADER **ppibhInfo, OPTIONAL OUT PMPR_INTERFACE_0 pMprIfInfo, OPTIONAL OUT PDWORD pdwIfType OPTIONAL )
/*++
Routine Description:
Gets global transport information from registry or router.
If one of the out information is not required, then the parameter can be NULL. Arguments:
pwszIfName - Interface Name bMprConfig - Info from Registry or info from router ppibhInfo - ptr to header pMprIfInfo - ptr to interface info pdwIfType - Type of interface Return Value:
NO_ERROR, ERROR_NO_SUCH_INTERFACE ERROR_TRANSPORT_NOT_PRESENT
--*/
{ PMPR_INTERFACE_0 pMprIf = NULL; PRTR_INFO_BLOCK_HEADER pibh; HANDLE hInterface,hIfTransport; DWORD dwRes, dwSize;
if(((ULONG_PTR)ppibhInfo | (ULONG_PTR)pMprIfInfo | (ULONG_PTR)pdwIfType) == (ULONG_PTR)NULL) { return NO_ERROR; } do {
#ifdef READROUTERINFO
if(IsRouterRunning()) { //
// Get info from the router
//
dwRes = MprAdminInterfaceGetHandle(g_hMprAdmin, (LPWSTR)pwszIfName, &hInterface, FALSE);
if( dwRes != NO_ERROR ) { break; }
if(pMprIfInfo || pdwIfType) { dwRes = MprAdminInterfaceGetInfo(g_hMprAdmin, hInterface, 0, (LPBYTE *) &pMprIf);
if ( dwRes != NO_ERROR ) { break; }
if (pMprIf == NULL) { dwRes = ERROR_NOT_ENOUGH_MEMORY; break; } if(pMprIfInfo) { //
// structure copy
//
*pMprIfInfo= *pMprIf; }
if(pdwIfType) { *pdwIfType = pMprIf->dwIfType; }
MprAdminBufferFree(pMprIf);
}
if(ppibhInfo) { dwRes = MprAdminInterfaceTransportGetInfo(g_hMprAdmin, hInterface, PID_IP, (LPBYTE*) &pibh, &dwSize);
if(dwRes != NO_ERROR) { break; } if(pibh == (PRTR_INFO_BLOCK_HEADER) NULL) { dwRes = ERROR_TRANSPORT_NOT_PRESENT;
break; }
//
// The info returned to the user must be from
// process heap. Admin calls use MIDL allocation, so
// copy out info
//
*ppibhInfo = HeapAlloc(GetProcessHeap(), 0, dwSize);
if(*ppibhInfo == NULL) { dwRes = GetLastError();
break; }
CopyMemory(*ppibhInfo, pibh, dwSize);
MprAdminBufferFree(pibh); }
} else#endif
{#ifdef READROUTERINFO
//
// Router not running, get info from the registry
//
#else
//
// Always get the information from the registry.
// Doesn't matter if the router is running or not.
// When setting the interface information,
// write it to registry and to the router (if it is running).
//
#endif
dwRes = MprConfigInterfaceGetHandle(g_hMprConfig, (LPWSTR)pwszIfName, &hInterface);
if(dwRes != NO_ERROR) { break; }
if(pMprIfInfo || pdwIfType) { dwRes = MprConfigInterfaceGetInfo(g_hMprConfig, hInterface, 0, (LPBYTE *) &pMprIf, &dwSize); if(dwRes != NO_ERROR) { break; }
if (pMprIf == NULL) { dwRes = ERROR_NOT_ENOUGH_MEMORY; break; } if(pdwIfType) { *pdwIfType = pMprIf->dwIfType; }
if(pMprIfInfo) { *pMprIfInfo = *pMprIf; }
MprConfigBufferFree(pMprIf); } if (ppibhInfo) { dwRes = MprConfigInterfaceTransportGetHandle(g_hMprConfig, hInterface, PID_IP, &hIfTransport);
if(dwRes != NO_ERROR) { break; } dwRes = MprConfigInterfaceTransportGetInfo(g_hMprConfig, hInterface, hIfTransport, (LPBYTE*) &pibh, &dwSize);
if(dwRes != NO_ERROR) { break; } if((pibh == (PRTR_INFO_BLOCK_HEADER) NULL) or (dwSize < sizeof(RTR_INFO_BLOCK_HEADER))) { dwRes = ERROR_TRANSPORT_NOT_PRESENT;
break; }
//
// Again, since this is also allocated from process heap
//
*ppibhInfo = pibh; } }
} while (FALSE);
return dwRes;}
DWORDMakeIPGlobalInfo( LPBYTE* ppBuff ){
DWORD dwSize = 0, dwRes = (DWORD) -1; LPBYTE pbDataPtr = (LPBYTE) NULL;
PRTR_TOC_ENTRY pTocEntry = (PRTR_TOC_ENTRY) NULL;
PGLOBAL_INFO pGlbInfo = NULL; PPRIORITY_INFO pPriorInfo = NULL;
PRTR_INFO_BLOCK_HEADER pIBH = (PRTR_INFO_BLOCK_HEADER) NULL;
//
// Alocate for minimal global Information
//
dwSize = sizeof( RTR_INFO_BLOCK_HEADER ) + sizeof(GLOBAL_INFO) + sizeof( RTR_TOC_ENTRY ) + SIZEOF_PRIORITY_INFO(7) + 2 * ALIGN_SIZE;
pIBH = (PRTR_INFO_BLOCK_HEADER) HeapAlloc( GetProcessHeap(), 0, dwSize );
if ( pIBH == (PRTR_INFO_BLOCK_HEADER) NULL ) { DisplayMessage( g_hModule, MSG_IP_NOT_ENOUGH_MEMORY ); *ppBuff = (LPBYTE) NULL; return ERROR_NOT_ENOUGH_MEMORY; }
//
// init. infobase fields
//
*ppBuff = (LPBYTE) pIBH;
pIBH-> Version = RTR_INFO_BLOCK_VERSION; pIBH-> TocEntriesCount = 2; pIBH-> Size = dwSize;
pbDataPtr = (LPBYTE) &( pIBH-> TocEntry[ pIBH-> TocEntriesCount ] ); ALIGN_POINTER( pbDataPtr );
//
// make IP rtr mgr global info.
//
pTocEntry = &(pIBH-> TocEntry[ 0 ]);
pTocEntry-> InfoType = IP_GLOBAL_INFO; pTocEntry-> Count = 1; pTocEntry-> Offset = (ULONG)(pbDataPtr - (PBYTE) pIBH); pTocEntry-> InfoSize = sizeof(GLOBAL_INFO);
pGlbInfo = (PGLOBAL_INFO) pbDataPtr; pGlbInfo-> bFilteringOn = TRUE; pGlbInfo-> dwLoggingLevel = IPRTR_LOGGING_ERROR;
pbDataPtr += pTocEntry->Count * pTocEntry-> InfoSize; ALIGN_POINTER( pbDataPtr ); //
// make IP rtr priority. Info
//
pTocEntry = &(pIBH-> TocEntry[ 1 ]);
pTocEntry-> InfoType = IP_PROT_PRIORITY_INFO; pTocEntry-> Count = 1; pTocEntry-> Offset = (DWORD)(pbDataPtr - (PBYTE) pIBH); pTocEntry-> InfoSize = SIZEOF_PRIORITY_INFO(7);
pPriorInfo = (PPRIORITY_INFO) pbDataPtr; pPriorInfo-> dwNumProtocols = 7;
pPriorInfo-> ppmProtocolMetric[ 0 ].dwProtocolId = PROTO_IP_LOCAL; pPriorInfo-> ppmProtocolMetric[ 0 ].dwMetric = 1;
pPriorInfo-> ppmProtocolMetric[ 1 ].dwProtocolId = PROTO_IP_NT_STATIC; pPriorInfo-> ppmProtocolMetric[ 1 ].dwMetric = 3;
pPriorInfo-> ppmProtocolMetric[ 2 ].dwProtocolId = PROTO_IP_NT_STATIC_NON_DOD; pPriorInfo-> ppmProtocolMetric[ 2 ].dwMetric = 5;
pPriorInfo-> ppmProtocolMetric[ 3 ].dwProtocolId = PROTO_IP_NT_AUTOSTATIC; pPriorInfo-> ppmProtocolMetric[ 3 ].dwMetric = 7;
pPriorInfo-> ppmProtocolMetric[ 4 ].dwProtocolId = PROTO_IP_NETMGMT; pPriorInfo-> ppmProtocolMetric[ 4 ].dwMetric = 10;
pPriorInfo-> ppmProtocolMetric[ 5 ].dwProtocolId = PROTO_IP_OSPF; pPriorInfo-> ppmProtocolMetric[ 5 ].dwMetric = 110;
pPriorInfo-> ppmProtocolMetric[ 6 ].dwProtocolId = PROTO_IP_RIP; pPriorInfo-> ppmProtocolMetric[ 6 ].dwMetric = 120;
return NO_ERROR;}
DWORD MakeIPInterfaceInfo( LPBYTE* ppBuff, DWORD dwIfType ){ DWORD dwSize = (DWORD) -1; DWORD dwTocEntries = 2; LPBYTE pbDataPtr = (LPBYTE) NULL;
PRTR_TOC_ENTRY pTocEntry = (PRTR_TOC_ENTRY) NULL;
#if 0
PRTR_DISC_INFO pRtrDisc = (PRTR_DISC_INFO) NULL;#endif
PINTERFACE_STATUS_INFO pifStat = (PINTERFACE_STATUS_INFO) NULL;
PRTR_INFO_BLOCK_HEADER pIBH = (PRTR_INFO_BLOCK_HEADER) NULL;
#ifdef KSL_IPINIP
PIPINIP_CONFIG_INFO pIpIpCfg;#endif //KSL_IPINIP
//
// Allocate for minimal interface Info.
// a TOC entry is allocated for IP_ROUTE_INFO, but no route info
// block is created, since initially there are no static routes.
//
dwSize = sizeof( RTR_INFO_BLOCK_HEADER ) + sizeof( RTR_TOC_ENTRY ) + sizeof( INTERFACE_STATUS_INFO ) + 2 * ALIGN_SIZE;
#if 0
if (dwIfType is ROUTER_IF_TYPE_DEDICATED) { dwSize += sizeof( RTR_TOC_ENTRY ) + sizeof( RTR_DISC_INFO ) + ALIGN_SIZE;
dwTocEntries++; }#endif
pIBH = (PRTR_INFO_BLOCK_HEADER) HeapAlloc( GetProcessHeap(), 0, dwSize ); if ( pIBH == (PRTR_INFO_BLOCK_HEADER) NULL ) { *ppBuff = (LPBYTE) NULL; DisplayMessage( g_hModule, MSG_IP_NOT_ENOUGH_MEMORY ); return ERROR_NOT_ENOUGH_MEMORY; }
*ppBuff = (LPBYTE) pIBH;
pIBH-> Version = RTR_INFO_BLOCK_VERSION; pIBH-> TocEntriesCount = dwTocEntries; pIBH-> Size = dwSize;
pbDataPtr = (LPBYTE) &( pIBH-> TocEntry[ pIBH-> TocEntriesCount ] ); ALIGN_POINTER( pbDataPtr );
//
// Create empty route info block
//
pTocEntry = (PRTR_TOC_ENTRY) &( pIBH-> TocEntry[ 0 ] ); pTocEntry-> InfoType = IP_ROUTE_INFO; pTocEntry-> InfoSize = sizeof( MIB_IPFORWARDROW ); pTocEntry-> Count = 0; pTocEntry-> Offset = (ULONG) (pbDataPtr - (PBYTE) pIBH); pbDataPtr += pTocEntry-> Count * pTocEntry-> InfoSize; ALIGN_POINTER( pbDataPtr ); //
// Create interface status block.
//
pTocEntry = (PRTR_TOC_ENTRY) &( pIBH-> TocEntry[ 1 ] ); pTocEntry-> InfoType = IP_INTERFACE_STATUS_INFO; pTocEntry-> InfoSize = sizeof( INTERFACE_STATUS_INFO ); pTocEntry-> Count = 1; pTocEntry-> Offset = (ULONG) (pbDataPtr - (LPBYTE) pIBH); pifStat = (PINTERFACE_STATUS_INFO) pbDataPtr; pifStat-> dwAdminStatus = g_dwIfState; pbDataPtr += pTocEntry-> Count * pTocEntry-> InfoSize; ALIGN_POINTER( pbDataPtr ); #if 0
if (dwIfType is ROUTER_IF_TYPE_DEDICATED) { //
// Create Router Disc. Info.
//
pTocEntry = (PRTR_TOC_ENTRY) &( pIBH-> TocEntry[ 2 ]); pTocEntry-> InfoType = IP_ROUTER_DISC_INFO; pTocEntry-> InfoSize = sizeof( RTR_DISC_INFO ); pTocEntry-> Count = 1; pTocEntry-> Offset = (ULONG) (pbDataPtr - (LPBYTE) pIBH); pRtrDisc = (PRTR_DISC_INFO) pbDataPtr; pRtrDisc-> bAdvertise = TRUE; pRtrDisc-> wMaxAdvtInterval = g_wMaxAdvtInterval; pRtrDisc-> wMinAdvtInterval = g_wMinAdvtInterval; pRtrDisc-> wAdvtLifetime = g_wAdvtLifeTime; pRtrDisc-> lPrefLevel = g_lPrefLevel;
pbDataPtr += pTocEntry-> Count * pTocEntry-> InfoSize;
ALIGN_POINTER( pbDataPtr ); }#endif
return NO_ERROR;}
DWORDAddInterfaceInfo( IN LPCWSTR pwszIfName ){ DWORD dwRes = (DWORD) -1, dwIfType, dwSize = 0; BOOL bAddRtrMgr = FALSE;
HANDLE hInterface = (HANDLE) NULL, hTransport = (HANDLE) NULL, hIfAdmin = (HANDLE) NULL, hIfTransport = (HANDLE) NULL;
PRTR_INFO_BLOCK_HEADER pibhTmp = (PRTR_INFO_BLOCK_HEADER) NULL;
#ifdef EXTRA_DEBUG
PRINT(L"AddInterfaceInfo:"); PRINT(pwszIfName);#endif
do { PMPR_INTERFACE_0 pmiIfInfo;
//
// verify interface name.
//
dwRes = MprConfigInterfaceGetHandle( g_hMprConfig, (LPWSTR)pwszIfName, &hInterface ); if ( dwRes != NO_ERROR ) { DisplayMessage( g_hModule, MSG_NO_INTERFACE, pwszIfName ); break; }
// Make sure interface exists
dwRes = MprConfigInterfaceGetInfo(g_hMprConfig, hInterface, 0, (BYTE **)&pmiIfInfo, &dwSize); if( dwRes != NO_ERROR ) { DisplayError( NULL, dwRes ); break; }
dwIfType = pmiIfInfo->dwIfType;
#ifdef KSL_IPINIP
// Here's a hack due apparently due to the inability of
// the current stack to do Foo-over-IP tunnels, so adding
// an ipip tunnel both creates the tunnel and enables IP
// on it.
if(dwIfType is ROUTER_IF_TYPE_TUNNEL1) { MprConfigBufferFree(pmiIfInfo);
dwRes = ERROR_INVALID_PARAMETER; DisplayMessage(g_hModule, MSG_IP_IF_IS_TUNNEL);
break; }#endif //KSL_IPINIP
MprConfigBufferFree(pmiIfInfo);
//
// Is IP RtrMgr present on this router.
//
// if specified IP router manager is absent,
// we shall need to add global info for this
// router manager "before" we add the interface
// information
//
//
// Try to get a handle to the rtr mgr.
//
dwRes = MprConfigTransportGetHandle(g_hMprConfig, PID_IP, &hTransport); if ( dwRes != NO_ERROR ) { if ( dwRes == ERROR_UNKNOWN_PROTOCOL_ID ) { bAddRtrMgr = TRUE; } else { DisplayError( NULL, dwRes ); break; } }
//
// if handle is available, try to retrieve global info.
// if not available we shall need to add the global info.
//
if ( !bAddRtrMgr ) { dwRes = MprConfigTransportGetInfo(g_hMprConfig, hTransport, (LPBYTE*) &pibhTmp, &dwSize, NULL, NULL, NULL); if ( dwRes != NO_ERROR ) { DisplayError( NULL, dwRes ); break; }
if ( pibhTmp == (PRTR_INFO_BLOCK_HEADER) NULL ) { bAddRtrMgr = TRUE; }
else { MprConfigBufferFree( pibhTmp ); pibhTmp = NULL; } }
//
// If IP is already present on router, see if IP was already
// added to the interface. If so, complain.
//
if ( !bAddRtrMgr ) { dwRes = MprConfigInterfaceTransportGetHandle(g_hMprConfig, hInterface, PID_IP, &hIfTransport); if ( dwRes == NO_ERROR ) { dwRes = ERROR_INVALID_PARAMETER; // was SetInterfaceInRouterConfig(); to update
break; } }
//
// If IP RtrMgr is not present, add global info.
//
if ( bAddRtrMgr ) { dwRes = MakeIPGlobalInfo( (LPBYTE *)&pibhTmp ); if ( dwRes != NO_ERROR ) { break; } dwRes = MprConfigTransportCreate( g_hMprConfig, PID_IP, IP_KEY, (LPBYTE) pibhTmp, pibhTmp-> Size, NULL, 0, g_wszRtrMgrDLL, &hTransport ); if ( dwRes != NO_ERROR ) { DisplayError( NULL, dwRes ); break; }
HeapFree( GetProcessHeap(), 0, pibhTmp ); }
pibhTmp = (PRTR_INFO_BLOCK_HEADER) NULL;
//
// Add IP Rtr Mgr. information for the interface
//
dwRes = MakeIPInterfaceInfo( (LPBYTE*) &pibhTmp, dwIfType);
if ( dwRes != NO_ERROR ) { break; }
dwRes = MprConfigInterfaceTransportAdd( g_hMprConfig, hInterface, PID_IP, IP_KEY, (LPBYTE) pibhTmp, pibhTmp-> Size, &hIfTransport ); if ( dwRes != NO_ERROR ) { DisplayError( NULL, dwRes ); break; }
if(IsRouterRunning()) { dwRes = MprAdminInterfaceGetHandle(g_hMprAdmin, (LPWSTR)pwszIfName, &hIfAdmin, FALSE);
if ( dwRes != NO_ERROR ) { break; }
dwRes = MprAdminInterfaceTransportAdd( g_hMprAdmin, hIfAdmin, PID_IP, (LPBYTE) pibhTmp, pibhTmp->Size );
if ( dwRes != NO_ERROR ) { DisplayMessage( g_hModule, ERROR_ADMIN, dwRes ); break; }
break; }
} while( FALSE );
//
// Free all allocations
//
if ( pibhTmp ) { HeapFree( GetProcessHeap(), 0, pibhTmp ); }
return dwRes;}
DWORDDeleteInterfaceInfo( IN LPCWSTR pwszIfName ){ DWORD dwRes, dwIfType = 0, dwErr; HANDLE hIfTransport, hInterface;
do { dwRes = MprConfigInterfaceGetHandle(g_hMprConfig, (LPWSTR)pwszIfName, &hInterface); if ( dwRes != NO_ERROR ) { break; } //
// Get the type of the interface
//
dwErr = GetInterfaceInfo(pwszIfName, NULL, NULL, &dwIfType);
if(dwErr != NO_ERROR) { break; }
dwRes = MprConfigInterfaceTransportGetHandle(g_hMprConfig, hInterface, PID_IP, &hIfTransport); if ( dwRes != NO_ERROR ) { break; } dwRes = MprConfigInterfaceTransportRemove(g_hMprConfig, hInterface, hIfTransport);
#ifdef KSL_IPINIP
//
// If its an ip in ip tunnel, clear out its name and delete from the
// router
//
if(dwIfType == ROUTER_IF_TYPE_TUNNEL1) { dwRes = MprConfigInterfaceDelete(g_hMprConfig, hInterface);
if(dwRes == NO_ERROR) { GUID Guid;
dwRes = ConvertStringToGuid(pwszIfName, (USHORT)(wcslen(pwszIfName) * sizeof(WCHAR)), &Guid); if(dwRes != NO_ERROR) { break; }
MprSetupIpInIpInterfaceFriendlyNameDelete(g_pwszRouter, &Guid); } }#endif //KSL_IPINIP
if(IsRouterRunning()) { dwRes = MprAdminInterfaceGetHandle(g_hMprAdmin, (LPWSTR)pwszIfName, &hInterface, FALSE);
if ( dwRes != NO_ERROR ) { break; }
dwRes = MprAdminInterfaceTransportRemove(g_hMprAdmin, hInterface, PID_IP);
#ifdef KSL_IPINIP
if(dwIfType == ROUTER_IF_TYPE_TUNNEL1) { dwRes = MprAdminInterfaceDelete(g_hMprAdmin, hInterface); }#endif //KSL_IPINIP
break; } } while (FALSE);
return dwRes;}
DWORDSetInterfaceInfo( IN PRTR_INFO_BLOCK_HEADER pibhInfo, IN LPCWSTR pwszIfName )
/*++
Routine Description:
Sets interface transport information in registry or router. Arguments:
pwszIfName - Interface Name pibhInfo - ptr to header Return Value:
NO_ERROR, ERROR_ROUTER_STOPPED --*/
{ DWORD dwARes = NO_ERROR, dwCRes = NO_ERROR; HANDLE hIfTransport, hInterface; UINT i; PRTR_INFO_BLOCK_HEADER pibhNewInfo, pibhOldInfo;
//
// Create a new info block with all 0-length blocks removed
// since we don't want to write them to the registry,
// we only need to send them to the router which we
// will do with the original info block below.
//
pibhNewInfo = pibhInfo; pibhOldInfo = NULL;
for (i=0; (dwCRes is NO_ERROR) && (i<pibhInfo->TocEntriesCount); i++) { if (pibhInfo->TocEntry[i].InfoSize is 0) { pibhOldInfo = pibhNewInfo;
dwCRes = MprInfoBlockRemove(pibhOldInfo, pibhInfo->TocEntry[i].InfoType, &pibhNewInfo);
if (pibhOldInfo isnot pibhInfo) { FREE_BUFFER(pibhOldInfo); } } }
if (dwCRes is NO_ERROR) { dwCRes = MprConfigInterfaceGetHandle(g_hMprConfig, (LPWSTR)pwszIfName, &hInterface); }
if (dwCRes is NO_ERROR) { dwCRes = MprConfigInterfaceTransportGetHandle(g_hMprConfig, hInterface, PID_IP, &hIfTransport); }
if (dwCRes is NO_ERROR) { dwCRes = MprConfigInterfaceTransportSetInfo(g_hMprConfig, hInterface, hIfTransport, (LPBYTE) pibhNewInfo, pibhNewInfo->Size); }
if (pibhNewInfo isnot pibhInfo) { FREE_BUFFER(pibhNewInfo); }
//
// Even if we failed to write to the registry, we still want
// to write to the router.
//
// We use the original format when writing to the router, since it
// needs to see the 0-length blocks in order to delete config info.
//
if(IsRouterRunning()) { dwARes = MprAdminInterfaceGetHandle(g_hMprAdmin, (LPWSTR)pwszIfName, &hInterface, FALSE);
if (dwARes is NO_ERROR) { dwARes = MprAdminInterfaceTransportSetInfo(g_hMprAdmin, hInterface, PID_IP, (LPBYTE) pibhInfo, pibhInfo->Size); } }
return (dwARes isnot NO_ERROR)? dwARes : dwCRes;}
DWORDWINAPIIpCommit( IN DWORD dwAction ){ PINTERFACE_STORE pii; PLIST_ENTRY ple, pleTmp; BOOL bCommit, bFlush = FALSE;
switch(dwAction) { case NETSH_COMMIT: { if (g_bCommit == TRUE) { return NO_ERROR; }
g_bCommit = TRUE;
break; }
case NETSH_UNCOMMIT: { g_bCommit = FALSE;
return NO_ERROR; }
case NETSH_SAVE: { if (g_bCommit) { return NO_ERROR; }
break; }
case NETSH_FLUSH: { //
// Action is a flush. If current state is commit, then
// nothing to be done.
if (g_bCommit) { return NO_ERROR; }
bFlush = TRUE;
break; }
default: { return NO_ERROR; } }
//
// Switched to commit mode. So set all valid info in the
// strutures. Free memory and invalidate the info.
//
if((g_tiTransport.bValid && g_tiTransport.pibhInfo) && !bFlush) { SetGlobalInfo(g_tiTransport.pibhInfo);
}
g_tiTransport.bValid = FALSE;
if(g_tiTransport.pibhInfo) { FREE_BUFFER(g_tiTransport.pibhInfo);
g_tiTransport.pibhInfo = NULL; }
//
// Set the interface info
//
while(!IsListEmpty(&g_leIfListHead)) { ple = RemoveHeadList(&g_leIfListHead);
pii = CONTAINING_RECORD(ple, INTERFACE_STORE, le);
if ((pii->bValid && pii->pibhInfo) && !bFlush) { // Set the info in config
SetInterfaceInfo(pii->pibhInfo, pii->pwszIfName); }
pii->bValid = FALSE;
if(pii->pibhInfo) { FREE_BUFFER(pii->pibhInfo);
pii->pibhInfo = NULL; }
if(pii->pwszIfName) { HeapFree(GetProcessHeap(), 0, pii->pwszIfName);
pii->pwszIfName = NULL; }
//
// Free the list entry
//
HeapFree(GetProcessHeap(), 0, pii); }
return NO_ERROR;}
#ifdef KSL_IPINIP
DWORDCreateInterface( IN LPCWSTR pwszFriendlyName, IN LPCWSTR pwszGuidName, IN DWORD dwIfType, IN BOOL bCreateRouterIf )
{ DWORD i, dwErr, dwType, dwSize; HANDLE hIfCfg, hIfAdmin, hIfTransport; PBYTE pbyData;
PRTR_INFO_BLOCK_HEADER pInfo; PINTERFACE_STATUS_INFO pStatus;#if 0
PRTR_DISC_INFO pDisc;#endif
//
// The only type we can create in the router is TUNNEL1
//
if(dwIfType != ROUTER_IF_TYPE_TUNNEL1) { ASSERT(FALSE);
return ERROR_INVALID_PARAMETER; }
hIfAdmin = NULL; hIfCfg = NULL;
if(bCreateRouterIf) { MPR_INTERFACE_0 IfInfo;
//
// The caller wants us to create an interface in the router, also
//
wcsncpy(IfInfo.wszInterfaceName, pwszGuidName, MAX_INTERFACE_NAME_LEN);
IfInfo.fEnabled = TRUE;
IfInfo.dwIfType = dwIfType;
IfInfo.wszInterfaceName[MAX_INTERFACE_NAME_LEN] = UNICODE_NULL;
dwErr = MprConfigInterfaceCreate(g_hMprConfig, 0, (PBYTE)&IfInfo, &hIfCfg);
if(dwErr isnot NO_ERROR) { DisplayError(NULL, dwErr);
return dwErr; }
//
// if router service is running add the interface
// to it too.
//
if(IsRouterRunning()) { dwErr = MprAdminInterfaceCreate(g_hMprAdmin, 0, (PBYTE)&IfInfo, &hIfAdmin);
if(dwErr isnot NO_ERROR) { DisplayError(NULL, dwErr);
MprConfigInterfaceDelete(g_hMprConfig, hIfCfg); return dwErr; } } } else { //
// The interface existed in the router but not in IP
//
dwErr = MprConfigInterfaceGetHandle(g_hMprConfig, (LPWSTR)pwszGuidName, &hIfCfg);
if(dwErr isnot NO_ERROR) { DisplayError(NULL, dwErr);
return dwErr; }
if(IsRouterRunning()) { dwErr = MprAdminInterfaceGetHandle(g_hMprAdmin, (LPWSTR)pwszGuidName, &hIfAdmin, FALSE);
if(dwErr isnot NO_ERROR) { DisplayError(NULL, dwErr);
return dwErr; } } }
//
// At this point we have an interface which doesnt have IP on it
// We have the handles to config and admin (if router is running)
// Set the default information for the interface
//
dwSize = FIELD_OFFSET(RTR_INFO_BLOCK_HEADER, TocEntry[0]);
dwSize += (sizeof(INTERFACE_STATUS_INFO) + sizeof(RTR_TOC_ENTRY) + ALIGN_SIZE);
#if 0
dwSize += (sizeof(RTR_DISC_INFO) + sizeof(RTR_TOC_ENTRY) + ALIGN_SIZE);#endif
pInfo = HeapAlloc(GetProcessHeap(), 0, dwSize);
if(pInfo is NULL) { DisplayError(NULL, ERROR_NOT_ENOUGH_MEMORY);
if(bCreateRouterIf) { MprConfigInterfaceDelete(g_hMprConfig, hIfCfg); }
return ERROR_NOT_ENOUGH_MEMORY; }
pInfo->Version = IP_ROUTER_MANAGER_VERSION; pInfo->TocEntriesCount = 1; pInfo->Size = dwSize;
//
// Make data point to N+1th entry
//
pbyData = (PBYTE)&(pInfo->TocEntry[1]);
ALIGN_POINTER(pbyData);
pStatus = (PINTERFACE_STATUS_INFO)pbyData;
pStatus->dwAdminStatus = IF_ADMIN_STATUS_UP;
pInfo->TocEntry[0].InfoSize = sizeof(INTERFACE_STATUS_INFO); pInfo->TocEntry[0].InfoType = IP_INTERFACE_STATUS_INFO; pInfo->TocEntry[0].Count = 1; pInfo->TocEntry[0].Offset = (ULONG)(pbyData - (PBYTE)pInfo);
pbyData = (PBYTE)((ULONG_PTR)pbyData + sizeof(INTERFACE_STATUS_INFO));
ALIGN_POINTER(pbyData);
#if 0
pDisc = (PRTR_DISC_INFO)pbyData;
pDisc->wMaxAdvtInterval = DEFAULT_MAX_ADVT_INTERVAL; pDisc->wMinAdvtInterval = (WORD)(DEFAULT_MIN_ADVT_INTERVAL_RATIO * DEFAULT_MAX_ADVT_INTERVAL); pDisc->wAdvtLifetime = DEFAULT_ADVT_LIFETIME_RATIO * DEFAULT_MAX_ADVT_INTERVAL; pDisc->bAdvertise = FALSE; pDisc->lPrefLevel = DEFAULT_PREF_LEVEL;
pInfo->TocEntry[1].InfoSize = sizeof(RTR_DISC_INFO); pInfo->TocEntry[1].InfoType = IP_ROUTER_DISC_INFO; pInfo->TocEntry[1].Count = 1; pInfo->TocEntry[1].Offset = (ULONG)(pbyData - (PBYTE)pInfo);#endif
dwErr = MprConfigInterfaceTransportAdd(g_hMprConfig, hIfCfg, PID_IP, IP_KEY, (PBYTE) pInfo, dwSize, &hIfTransport);
if(dwErr isnot NO_ERROR) { HeapFree(GetProcessHeap(), 0, pInfo);
DisplayMessage(g_hModule, EMSG_CANT_CREATE_IF, pwszFriendlyName, dwErr);
if(bCreateRouterIf) { MprConfigInterfaceDelete(g_hMprConfig, hIfCfg); }
return dwErr; }
if(hIfAdmin isnot NULL) { dwErr = MprAdminInterfaceTransportAdd(g_hMprAdmin, hIfAdmin, PID_IP, (PBYTE) pInfo, dwSize);
if(dwErr isnot NO_ERROR) { DisplayMessage(g_hModule, EMSG_CANT_CREATE_IF, pwszFriendlyName, dwErr);
MprConfigInterfaceTransportRemove(g_hMprConfig, hIfCfg, hIfTransport);
if(bCreateRouterIf) { MprConfigInterfaceDelete(g_hMprConfig, hIfCfg); }
} }
HeapFree(GetProcessHeap(), 0, pInfo);
return NO_ERROR;}#endif //KSL_IPINIP
DWORDGetInterfaceClass( IN LPCWSTR pwszIfName, OUT PDWORD pdwIfClass )/*++
Description: Determine whether an interface is of class Loopback, P2P, Subnet, or NBMA. Currently there is no global way to do this, so we test for some enumerated types and assume everything else is Subnet.Returns: IFCLASS_xxx (see info.h)--*/{ DWORD dwErr, dwType;
dwErr = GetInterfaceInfo(pwszIfName, NULL, NULL, &dwType);
if (dwErr) { return dwErr; }
switch (dwType) { case ROUTER_IF_TYPE_FULL_ROUTER : *pdwIfClass = IFCLASS_P2P; break; case ROUTER_IF_TYPE_INTERNAL : *pdwIfClass = IFCLASS_NBMA; break; case ROUTER_IF_TYPE_LOOPBACK : *pdwIfClass = IFCLASS_LOOPBACK; break;#ifdef KSL_IPINIP
case ROUTER_IF_TYPE_TUNNEL1 : *pdwIfClass = IFCLASS_P2P; break;#endif //KSL_IPINIP
case ROUTER_IF_TYPE_DIALOUT : *pdwIfClass = IFCLASS_P2P; break; default: *pdwIfClass = IFCLASS_BROADCAST; break; }
return NO_ERROR;}
|
