You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
906 lines
24 KiB
906 lines
24 KiB
/*++
|
|
|
|
Copyright (c) 1995 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
rpal.c
|
|
|
|
Abstract:
|
|
|
|
Routing protocols abstraction layer. It abstracts the RIP/SAP or NLSP routing
|
|
protocols interface functions for the rest of the router manager system.
|
|
|
|
Author:
|
|
|
|
Stefan Solomon 04/24/1995
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
//
|
|
// Service Table Manager Entry Points
|
|
//
|
|
|
|
PIS_SERVICE STM_IsService;
|
|
PCREATE_SERVICE_ENUMERATION_HANDLE STM_CreateServiceEnumerationHandle;
|
|
PENUMERATE_GET_NEXT_SERVICE STM_EnumerateGetNextService;
|
|
PCLOSE_SERVICE_ENUMERATION_HANDLE STM_CloseServiceEnumerationHandle;
|
|
PGET_SERVICE_COUNT STM_GetServiceCount;
|
|
PCREATE_STATIC_SERVICE STM_CreateStaticService;
|
|
PDELETE_STATIC_SERVICE STM_DeleteStaticService;
|
|
PBLOCK_CONVERT_SERVICES_TO_STATIC STM_BlockConvertServicesToStatic;
|
|
PBLOCK_DELETE_STATIC_SERVICES STM_BlockDeleteStaticServices;
|
|
PGET_FIRST_ORDERED_SERVICE STM_GetFirstOrderedService;
|
|
PGET_NEXT_ORDERED_SERVICE STM_GetNextOrderedService;
|
|
|
|
//
|
|
// Auto-Static Update Entry Points
|
|
//
|
|
|
|
ULONG UpdateRoutesProtId;
|
|
PDO_UPDATE_ROUTES RP_UpdateRoutes;
|
|
|
|
ULONG UpdateServicesProtId;
|
|
PDO_UPDATE_SERVICES RP_UpdateServices;
|
|
|
|
//
|
|
// Router Manager Support Functions - Passed to routing protocols at Start
|
|
//
|
|
|
|
SUPPORT_FUNCTIONS RMSupportFunctions = {
|
|
|
|
RoutingProtocolConnectionRequest,
|
|
MibCreate,
|
|
MibDelete,
|
|
MibSet,
|
|
MibGet,
|
|
MibGetFirst,
|
|
MibGetNext
|
|
|
|
};
|
|
|
|
|
|
//**************************************************************************
|
|
// *
|
|
// Routing Protocols Init/Start/Stop Functions *
|
|
// *
|
|
//**************************************************************************
|
|
|
|
DWORD
|
|
StartRoutingProtocols(LPVOID GlobalInfop,
|
|
HANDLE RoutingProtocolsEvent)
|
|
{
|
|
DWORD rc, i, count, namelen, support;
|
|
HINSTANCE moduleinstance;
|
|
PRPCB rpcbp;
|
|
LPVOID ProtocolGlobalInfop;
|
|
PIPX_GLOBAL_INFO IpxGlobalInfop;
|
|
MPR_PROTOCOL_0 *RtProtocolsp;
|
|
DWORD NumRoutingProtocols;
|
|
|
|
MPR_ROUTING_CHARACTERISTICS mrcRouting;
|
|
MPR_SERVICE_CHARACTERISTICS mscService;
|
|
|
|
// Initialize Routing Protocols List
|
|
//
|
|
InitializeListHead(&RoutingProtocolCBList);
|
|
|
|
rc = MprSetupProtocolEnum (PID_IPX, (LPBYTE *)&RtProtocolsp, &NumRoutingProtocols);
|
|
if (rc!=NO_ERROR) {
|
|
Trace (RPAL_TRACE,
|
|
"StartRoutingProtocols: failed to get routing protocol info: %d",
|
|
rc);
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
Trace (RPAL_TRACE, "StartRoutingProtocols: %d protocols installed.",
|
|
NumRoutingProtocols);
|
|
|
|
for (i=0; i<NumRoutingProtocols; i++) {
|
|
|
|
if (GetInfoEntry(GlobalInfop, RtProtocolsp[i].dwProtocolId)==NULL)
|
|
continue;
|
|
|
|
// load library on the dll name provided
|
|
//
|
|
moduleinstance = LoadLibraryW (RtProtocolsp[i].wszDLLName) ;
|
|
|
|
if (moduleinstance == NULL) {
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
LPWSTR pname[1] = {RtProtocolsp[i].wszDLLName};
|
|
RouterLogErrorW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_CANT_LOAD_PROTOCOL,
|
|
1, pname, rc);
|
|
}
|
|
Trace(RPAL_TRACE, "StartRoutingProtocols: %ls failed to load: %d\n", RtProtocolsp[i].wszDLLName, GetLastError());
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
namelen = sizeof(WCHAR) * (wcslen(RtProtocolsp[i].wszDLLName) + 1) ; // +1 for null character
|
|
|
|
rpcbp = (PRPCB) GlobalAlloc (GPTR, sizeof(RPCB) + namelen) ;
|
|
|
|
if (rpcbp == NULL) {
|
|
|
|
FreeLibrary (moduleinstance) ;
|
|
Trace(RPAL_TRACE, "StartRoutingProtocols: memory allocation failure\n");
|
|
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
ZeroMemory(rpcbp,
|
|
sizeof(RPCB) + namelen);
|
|
|
|
rpcbp->RP_DllName = (PWSTR)((PUCHAR)rpcbp + sizeof(RPCB));
|
|
rpcbp->RP_DllHandle = moduleinstance;
|
|
memcpy (rpcbp->RP_DllName, RtProtocolsp[i].wszDLLName, namelen) ;
|
|
|
|
// Loading all entrypoints
|
|
//
|
|
|
|
rpcbp->RP_RegisterProtocol =
|
|
(PREGISTER_PROTOCOL)GetProcAddress(moduleinstance,
|
|
REGISTER_PROTOCOL_ENTRY_POINT_STRING)
|
|
;
|
|
if(rpcbp->RP_RegisterProtocol == NULL)
|
|
{
|
|
//
|
|
// Could not find the RegisterProtocol entry point
|
|
// Nothing we can do - bail out
|
|
//
|
|
|
|
Sleep(0);
|
|
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
Trace(RPAL_TRACE, "StartRoutingProtocols: Could not find RegisterProtocol for %S",
|
|
RtProtocolsp[i].wszDLLName);
|
|
|
|
GlobalFree(rpcbp);
|
|
FreeLibrary(moduleinstance);
|
|
return ERROR_INVALID_FUNCTION;
|
|
}
|
|
|
|
ZeroMemory(&mrcRouting,
|
|
sizeof(MPR_ROUTING_CHARACTERISTICS));
|
|
|
|
ZeroMemory(&mscService,
|
|
sizeof(MPR_SERVICE_CHARACTERISTICS));
|
|
|
|
mrcRouting.dwVersion = MS_ROUTER_VERSION;
|
|
mrcRouting.dwProtocolId = RtProtocolsp[i].dwProtocolId;
|
|
mrcRouting.fSupportedFunctionality = ROUTING|DEMAND_UPDATE_ROUTES;
|
|
|
|
mscService.dwVersion = MS_ROUTER_VERSION;
|
|
mscService.dwProtocolId = RtProtocolsp[i].dwProtocolId;
|
|
mscService.fSupportedFunctionality = SERVICES|DEMAND_UPDATE_SERVICES;
|
|
|
|
rpcbp->RP_ProtocolId = RtProtocolsp[i].dwProtocolId;
|
|
|
|
rc = rpcbp->RP_RegisterProtocol(&mrcRouting,
|
|
&mscService);
|
|
|
|
if(rc != NO_ERROR)
|
|
{
|
|
Sleep(0);
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
CHAR num[8];
|
|
LPSTR pnum[1] = {num};
|
|
_ultoa (rpcbp->RP_ProtocolId, num, 16);
|
|
RouterLogErrorA (RMEventLogHdl,
|
|
ROUTERLOG_IPX_CANT_REGISTER_PROTOCOL,
|
|
1, pnum, rc);
|
|
}
|
|
|
|
FreeLibrary(moduleinstance);
|
|
|
|
GlobalFree(rpcbp);
|
|
|
|
Trace(RPAL_TRACE, "StartRoutingProtocols: %S returned error %d while registering",
|
|
RtProtocolsp[i].wszDLLName,
|
|
rc);
|
|
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
return rc;
|
|
}
|
|
|
|
rpcbp->RP_StartProtocol = mrcRouting.pfnStartProtocol;
|
|
rpcbp->RP_StopProtocol = mrcRouting.pfnStopProtocol;
|
|
rpcbp->RP_AddInterface = mrcRouting.pfnAddInterface;
|
|
rpcbp->RP_DeleteInterface = mrcRouting.pfnDeleteInterface;
|
|
rpcbp->RP_GetEventMessage = mrcRouting.pfnGetEventMessage;
|
|
rpcbp->RP_GetIfConfigInfo = mrcRouting.pfnGetInterfaceInfo;
|
|
rpcbp->RP_SetIfConfigInfo = mrcRouting.pfnSetInterfaceInfo;
|
|
rpcbp->RP_BindInterface = mrcRouting.pfnBindInterface;
|
|
rpcbp->RP_UnBindInterface = mrcRouting.pfnUnbindInterface;
|
|
rpcbp->RP_EnableInterface = mrcRouting.pfnEnableInterface;
|
|
rpcbp->RP_DisableInterface = mrcRouting.pfnDisableInterface;
|
|
rpcbp->RP_GetGlobalInfo = mrcRouting.pfnGetGlobalInfo;
|
|
rpcbp->RP_SetGlobalInfo = mrcRouting.pfnSetGlobalInfo;
|
|
rpcbp->RP_MibCreate = mrcRouting.pfnMibCreateEntry;
|
|
rpcbp->RP_MibDelete = mrcRouting.pfnMibDeleteEntry;
|
|
rpcbp->RP_MibGet = mrcRouting.pfnMibGetEntry;
|
|
rpcbp->RP_MibSet = mrcRouting.pfnMibSetEntry;
|
|
rpcbp->RP_MibGetFirst = mrcRouting.pfnMibGetFirstEntry;
|
|
rpcbp->RP_MibGetNext = mrcRouting.pfnMibGetNextEntry;
|
|
|
|
if (!(rpcbp->RP_RegisterProtocol) ||
|
|
!(rpcbp->RP_StartProtocol) ||
|
|
!(rpcbp->RP_StopProtocol) ||
|
|
!(rpcbp->RP_AddInterface) ||
|
|
!(rpcbp->RP_DeleteInterface) ||
|
|
!(rpcbp->RP_GetEventMessage) ||
|
|
!(rpcbp->RP_GetIfConfigInfo) ||
|
|
!(rpcbp->RP_SetIfConfigInfo) ||
|
|
!(rpcbp->RP_BindInterface) ||
|
|
!(rpcbp->RP_UnBindInterface) ||
|
|
!(rpcbp->RP_EnableInterface) ||
|
|
!(rpcbp->RP_DisableInterface) ||
|
|
!(rpcbp->RP_GetGlobalInfo) ||
|
|
!(rpcbp->RP_SetGlobalInfo) ||
|
|
!(rpcbp->RP_MibCreate) ||
|
|
!(rpcbp->RP_MibDelete) ||
|
|
!(rpcbp->RP_MibSet) ||
|
|
!(rpcbp->RP_MibGet) ||
|
|
!(rpcbp->RP_MibGetFirst) ||
|
|
!(rpcbp->RP_MibGetNext))
|
|
{
|
|
Trace(RPAL_TRACE, "StartRoutingProtocols: %ls failed to load entrypoints",
|
|
RtProtocolsp[i].wszDLLName);
|
|
|
|
GlobalFree(rpcbp);
|
|
FreeLibrary (moduleinstance);
|
|
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
if(mscService.fSupportedFunctionality & SERVICES)
|
|
{
|
|
STM_IsService = mscService.pfnIsService;
|
|
STM_CreateServiceEnumerationHandle = mscService.pfnCreateServiceEnumerationHandle;
|
|
STM_EnumerateGetNextService = mscService.pfnEnumerateGetNextService;
|
|
STM_CloseServiceEnumerationHandle = mscService.pfnCloseServiceEnumerationHandle;
|
|
STM_GetServiceCount = mscService.pfnGetServiceCount;
|
|
STM_CreateStaticService = mscService.pfnCreateStaticService;
|
|
STM_DeleteStaticService = mscService.pfnDeleteStaticService;
|
|
STM_BlockConvertServicesToStatic = mscService.pfnBlockConvertServicesToStatic;
|
|
STM_BlockDeleteStaticServices = mscService.pfnBlockDeleteStaticServices;
|
|
STM_GetFirstOrderedService = mscService.pfnGetFirstOrderedService;
|
|
STM_GetNextOrderedService = mscService.pfnGetNextOrderedService;
|
|
|
|
if(!(STM_IsService) ||
|
|
!(STM_CreateServiceEnumerationHandle) ||
|
|
!(STM_EnumerateGetNextService) ||
|
|
!(STM_CloseServiceEnumerationHandle) ||
|
|
!(STM_GetServiceCount) ||
|
|
!(STM_CreateStaticService) ||
|
|
!(STM_DeleteStaticService) ||
|
|
!(STM_BlockConvertServicesToStatic) ||
|
|
!(STM_BlockDeleteStaticServices) ||
|
|
!(STM_GetFirstOrderedService) ||
|
|
!(STM_GetNextOrderedService))
|
|
{
|
|
Trace(RPAL_TRACE, "StartRoutingProtocols: %ls failed to get STM entry points\n",
|
|
RtProtocolsp[i].wszDLLName);
|
|
|
|
GlobalFree(rpcbp);
|
|
FreeLibrary (moduleinstance);
|
|
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
}
|
|
|
|
|
|
if(mrcRouting.fSupportedFunctionality & DEMAND_UPDATE_ROUTES)
|
|
{
|
|
RP_UpdateRoutes = mrcRouting.pfnUpdateRoutes;
|
|
|
|
if(!RP_UpdateRoutes)
|
|
{
|
|
Trace(RPAL_TRACE,
|
|
"StartRoutingProtocols: %ls failed to get UpdateRoutes entry points\n",
|
|
RtProtocolsp[i].wszDLLName);
|
|
|
|
GlobalFree(rpcbp);
|
|
FreeLibrary (moduleinstance);
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
UpdateRoutesProtId = rpcbp->RP_ProtocolId;
|
|
}
|
|
|
|
if(mscService.fSupportedFunctionality & DEMAND_UPDATE_SERVICES)
|
|
{
|
|
RP_UpdateServices = mscService.pfnUpdateServices;
|
|
|
|
if(!RP_UpdateServices)
|
|
{
|
|
Trace(RPAL_TRACE,
|
|
"StartRoutingProtocols: %ls failed to get UpdateServices entry points\n",
|
|
RtProtocolsp[i].wszDLLName);
|
|
|
|
GlobalFree(rpcbp);
|
|
FreeLibrary (moduleinstance);
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
UpdateServicesProtId = rpcbp->RP_ProtocolId;
|
|
}
|
|
|
|
ProtocolGlobalInfop = GetInfoEntry(GlobalInfop, rpcbp->RP_ProtocolId);
|
|
|
|
if ((rc = (*rpcbp->RP_StartProtocol)(RoutingProtocolsEvent,
|
|
&RMSupportFunctions,
|
|
ProtocolGlobalInfop)) != NO_ERROR) {
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
CHAR num[8];
|
|
LPSTR pnum[1] = {num};
|
|
_ultoa (rpcbp->RP_ProtocolId, num, 16);
|
|
RouterLogErrorA (RMEventLogHdl,
|
|
ROUTERLOG_IPX_CANT_START_PROTOCOL,
|
|
1, pnum, rc);
|
|
}
|
|
Trace(RPAL_TRACE, "StartRoutingProtocols: %ls failed to start: %d\n",
|
|
RtProtocolsp[i].wszDLLName, rc);
|
|
|
|
GlobalFree(rpcbp);
|
|
FreeLibrary (moduleinstance);
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
// Insert this routing protocol in the list of routing protocols
|
|
//
|
|
InsertTailList(&RoutingProtocolCBList, &rpcbp->RP_Linkage);
|
|
RoutingProtocolActiveCount++;
|
|
Trace(RPAL_TRACE, "StartRoutingProtocols: %ls successfully initialized",
|
|
RtProtocolsp[i].wszDLLName);
|
|
}
|
|
|
|
if(!RP_UpdateRoutes || !RP_UpdateServices) {
|
|
|
|
Trace(RPAL_TRACE, "StartRoutingProtocols: missing update entry point\n");
|
|
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
MprSetupProtocolFree (RtProtocolsp);
|
|
|
|
Trace(RPAL_TRACE, "");
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
VOID
|
|
StopRoutingProtocols(VOID)
|
|
{
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
DWORD rc;
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList) {
|
|
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
(*rpcbp->RP_StopProtocol)();
|
|
lep = lep->Flink;
|
|
}
|
|
}
|
|
|
|
//**************************************************************************
|
|
// *
|
|
// Routing Protocols Interface Management Functions *
|
|
// *
|
|
//**************************************************************************
|
|
|
|
|
|
DWORD
|
|
CreateRoutingProtocolsInterfaces(PIPX_INFO_BLOCK_HEADER InterfaceInfop,
|
|
PICB icbp)
|
|
{
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
LPVOID RpIfInfop;
|
|
NET_INTERFACE_TYPE NetInterfaceType;
|
|
DWORD rc;
|
|
|
|
NetInterfaceType = MapIpxToNetInterfaceType(icbp);
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
RpIfInfop = GetInfoEntry(InterfaceInfop, rpcbp->RP_ProtocolId);
|
|
if(RpIfInfop == NULL) {
|
|
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
rc = (*rpcbp->RP_AddInterface)(
|
|
icbp->InterfaceNamep,
|
|
icbp->InterfaceIndex,
|
|
NetInterfaceType,
|
|
RpIfInfop);
|
|
|
|
if(rc != NO_ERROR) {
|
|
|
|
return rc;
|
|
}
|
|
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
DeleteRoutingProtocolsInterfaces(ULONG InterfaceIndex)
|
|
{
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
(*rpcbp->RP_DeleteInterface)(InterfaceIndex);
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
ULONG
|
|
SizeOfRoutingProtocolsIfsInfo(ULONG InterfaceIndex)
|
|
{
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
ULONG TotalInfoSize = 0;
|
|
ULONG RpIfInfoSize = 0;
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
(*rpcbp->RP_GetIfConfigInfo)(InterfaceIndex, NULL, &RpIfInfoSize);
|
|
// align size on double DWORD boundary - add two's complement for the last three bits
|
|
RpIfInfoSize += ((~RpIfInfoSize) + 1) & 0x7;
|
|
TotalInfoSize += RpIfInfoSize;
|
|
RpIfInfoSize = 0;
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return TotalInfoSize;
|
|
}
|
|
|
|
ULONG
|
|
RoutingProtocolsTocCount(VOID)
|
|
{
|
|
return(RoutingProtocolActiveCount);
|
|
}
|
|
|
|
/*++
|
|
|
|
Function: CreateRoutingProtocolsTocAndInfoEntries
|
|
|
|
Descr: as it says
|
|
|
|
Arguments: ibhp - ptr to the info block header
|
|
InterfaceIndex
|
|
current_tocepp - ptr to the location of the current TOC ptr; you have
|
|
to increment this to get to the next TOC -> your TOC!
|
|
current_NextInfoOffsetp - pointer to the location of the next info entry offset
|
|
in the info block; you have to use this for your info
|
|
entry and then to increment it for the next user.
|
|
--*/
|
|
|
|
DWORD
|
|
CreateRoutingProtocolsTocAndInfoEntries(PIPX_INFO_BLOCK_HEADER ibhp,
|
|
ULONG InterfaceIndex,
|
|
PIPX_TOC_ENTRY *current_tocepp,
|
|
PULONG current_NextInfoOffsetp)
|
|
{
|
|
PIPX_TOC_ENTRY tocep;
|
|
ULONG NextInfoOffset;
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
ULONG RpIfInfoSize;
|
|
DWORD rc;
|
|
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
// increment the current pointer to table of contents entries so it will
|
|
// point to the next entry
|
|
(*current_tocepp)++;
|
|
tocep = *current_tocepp;
|
|
|
|
// create the routing protocol and info toc entry
|
|
tocep->InfoType = rpcbp->RP_ProtocolId;
|
|
tocep->InfoSize = 0;
|
|
tocep->Count = 1;
|
|
tocep->Offset = *current_NextInfoOffsetp;
|
|
|
|
rc = (*rpcbp->RP_GetIfConfigInfo)(InterfaceIndex,
|
|
(LPVOID)((PUCHAR)ibhp + tocep->Offset),
|
|
&tocep->InfoSize);
|
|
|
|
if(rc != ERROR_INSUFFICIENT_BUFFER) {
|
|
|
|
return rc;
|
|
}
|
|
|
|
rc = (*rpcbp->RP_GetIfConfigInfo)(InterfaceIndex,
|
|
(LPVOID)((PUCHAR)ibhp + tocep->Offset),
|
|
&tocep->InfoSize);
|
|
|
|
if(rc != NO_ERROR) {
|
|
|
|
return rc;
|
|
}
|
|
|
|
*current_NextInfoOffsetp += tocep->InfoSize;
|
|
// align the next offset on DWORD boundary
|
|
*current_NextInfoOffsetp += (~*current_NextInfoOffsetp + 1) & 0x7;
|
|
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
SetRoutingProtocolsInterfaces(PIPX_INFO_BLOCK_HEADER InterfaceInfop,
|
|
ULONG InterfaceIndex)
|
|
{
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
LPVOID RpIfInfop;
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
RpIfInfop = GetInfoEntry(InterfaceInfop, rpcbp->RP_ProtocolId);
|
|
if(RpIfInfop == NULL) {
|
|
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
(*rpcbp->RP_SetIfConfigInfo)(InterfaceIndex, RpIfInfop);
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
BindRoutingProtocolsIfsToAdapter(ULONG InterfaceIndex,
|
|
PIPX_ADAPTER_BINDING_INFO abip)
|
|
{
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
(*rpcbp->RP_BindInterface)(InterfaceIndex, abip);
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
UnbindRoutingProtocolsIfsFromAdapter(ULONG InterfaceIndex)
|
|
{
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
(*rpcbp->RP_UnBindInterface)(InterfaceIndex);
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RoutingProtocolsEnableIpxInterface(ULONG InterfaceIndex)
|
|
{
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
(*rpcbp->RP_EnableInterface)(InterfaceIndex);
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RoutingProtocolsDisableIpxInterface(ULONG InterfaceIndex)
|
|
{
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
(*rpcbp->RP_DisableInterface)(InterfaceIndex);
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
//**************************************************************************
|
|
// *
|
|
// Routing Protocols Services Management Functions *
|
|
// *
|
|
//**************************************************************************
|
|
|
|
DWORD
|
|
GetFirstService(DWORD OrderingMethod,
|
|
DWORD ExclusionFlags,
|
|
PIPX_SERVICE Servicep)
|
|
{
|
|
return(*STM_GetFirstOrderedService)(OrderingMethod, ExclusionFlags, Servicep);
|
|
}
|
|
|
|
DWORD
|
|
GetNextService(DWORD OrderingMethod,
|
|
DWORD ExclusionFlags,
|
|
PIPX_SERVICE Servicep)
|
|
{
|
|
return(*STM_GetNextOrderedService)(OrderingMethod, ExclusionFlags, Servicep);
|
|
}
|
|
|
|
|
|
DWORD
|
|
CreateStaticService(PICB icbp,
|
|
PIPX_STATIC_SERVICE_INFO ServiceEntry)
|
|
{
|
|
DWORD rc;
|
|
|
|
rc = (*STM_CreateStaticService)(icbp->InterfaceIndex, ServiceEntry);
|
|
|
|
return rc;
|
|
}
|
|
|
|
DWORD
|
|
DeleteStaticService(ULONG InterfaceIndex,
|
|
PIPX_STATIC_SERVICE_INFO ServiceEntry)
|
|
{
|
|
DWORD rc;
|
|
|
|
rc = (*STM_DeleteStaticService)(InterfaceIndex, ServiceEntry);
|
|
|
|
return rc;
|
|
}
|
|
|
|
HANDLE
|
|
CreateStaticServicesEnumHandle(ULONG InterfaceIndex)
|
|
{
|
|
IPX_SERVICE CriteriaService;
|
|
HANDLE EnumHandle;
|
|
|
|
if(STM_CreateServiceEnumerationHandle == NULL) {
|
|
|
|
return NULL;
|
|
}
|
|
|
|
memset(&CriteriaService, 0, sizeof(IPX_SERVICE));
|
|
|
|
CriteriaService.InterfaceIndex = InterfaceIndex;
|
|
CriteriaService.Protocol = IPX_PROTOCOL_STATIC;
|
|
|
|
EnumHandle = (*STM_CreateServiceEnumerationHandle)(
|
|
STM_ONLY_THIS_INTERFACE | STM_ONLY_THIS_PROTOCOL,
|
|
&CriteriaService);
|
|
|
|
return EnumHandle;
|
|
}
|
|
|
|
DWORD
|
|
GetNextStaticService(HANDLE EnumHandle,
|
|
PIPX_STATIC_SERVICE_INFO StaticSvInfop)
|
|
{
|
|
IPX_SERVICE Service;
|
|
DWORD rc;
|
|
|
|
if((rc = (*STM_EnumerateGetNextService)(EnumHandle,
|
|
&Service)) == NO_ERROR) {
|
|
|
|
// fill in the static service structure
|
|
*StaticSvInfop = Service.Server;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
DWORD
|
|
CloseStaticServicesEnumHandle(HANDLE EnumHandle)
|
|
{
|
|
DWORD rc = NO_ERROR;
|
|
|
|
if(EnumHandle) {
|
|
|
|
rc = (*STM_CloseServiceEnumerationHandle)(EnumHandle);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
DWORD
|
|
DeleteAllStaticServices(ULONG InterfaceIndex)
|
|
{
|
|
if(!STM_BlockDeleteStaticServices) {
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
return((*STM_BlockDeleteStaticServices)(InterfaceIndex));
|
|
}
|
|
|
|
DWORD
|
|
GetServiceCount(VOID)
|
|
{
|
|
if(!STM_GetServiceCount) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
return((*STM_GetServiceCount)());
|
|
}
|
|
|
|
//**************************************************************************
|
|
// *
|
|
// Routing Protocols Auto-Static Update Functions *
|
|
// *
|
|
//**************************************************************************
|
|
|
|
DWORD
|
|
RtProtRequestRoutesUpdate(ULONG InterfaceIndex)
|
|
{
|
|
return((*RP_UpdateRoutes)(InterfaceIndex));
|
|
}
|
|
|
|
DWORD
|
|
RtProtRequestServicesUpdate(ULONG InterfaceIndex)
|
|
{
|
|
return((*RP_UpdateServices)(InterfaceIndex));
|
|
}
|
|
|
|
VOID
|
|
DestroyRoutingProtocolCB(PRPCB rpcbp)
|
|
{
|
|
RemoveEntryList(&rpcbp->RP_Linkage);
|
|
|
|
FreeLibrary (rpcbp->RP_DllHandle);
|
|
GlobalFree(rpcbp);
|
|
|
|
RoutingProtocolActiveCount--;
|
|
}
|
|
|
|
VOID
|
|
ConvertAllServicesToStatic(ULONG InterfaceIndex)
|
|
{
|
|
STM_BlockConvertServicesToStatic(InterfaceIndex);
|
|
}
|
|
|
|
DWORD
|
|
GetStaticServicesCount(ULONG InterfaceIndex)
|
|
{
|
|
HANDLE EnumHandle;
|
|
DWORD Count;
|
|
IPX_STATIC_SERVICE_INFO StaticSvInfo;
|
|
|
|
EnumHandle = CreateStaticServicesEnumHandle(InterfaceIndex);
|
|
|
|
if(EnumHandle == NULL) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
Count = 0;
|
|
while(GetNextStaticService(EnumHandle, &StaticSvInfo) == NO_ERROR) {
|
|
|
|
Count++;
|
|
}
|
|
|
|
CloseStaticServicesEnumHandle(EnumHandle);
|
|
|
|
return Count;
|
|
}
|
|
|
|
PRPCB
|
|
GetRoutingProtocolCB(DWORD ProtocolId)
|
|
{
|
|
PRPCB rpcbp;
|
|
PLIST_ENTRY lep;
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
if(rpcbp->RP_ProtocolId == ProtocolId) {
|
|
|
|
return rpcbp;
|
|
}
|
|
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL
|
|
IsService(USHORT SvType,
|
|
PUCHAR SvName,
|
|
PIPX_SERVICE Svp)
|
|
{
|
|
return(STM_IsService(SvType, SvName, Svp));
|
|
}
|
|
|
|
|
|
DWORD
|
|
SetRoutingProtocolsGlobalInfo(PIPX_INFO_BLOCK_HEADER GlobalInfop)
|
|
{
|
|
PLIST_ENTRY lep;
|
|
PRPCB rpcbp;
|
|
LPVOID RpGlobalInfop;
|
|
|
|
lep = RoutingProtocolCBList.Flink;
|
|
while(lep != &RoutingProtocolCBList)
|
|
{
|
|
|
|
rpcbp = CONTAINING_RECORD(lep, RPCB, RP_Linkage);
|
|
RpGlobalInfop = GetInfoEntry(GlobalInfop, rpcbp->RP_ProtocolId);
|
|
if(RpGlobalInfop == NULL) {
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
(*rpcbp->RP_SetGlobalInfo)(RpGlobalInfop);
|
|
lep = lep->Flink;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|