mirror of https://github.com/tongzx/nt5src
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.
1521 lines
40 KiB
1521 lines
40 KiB
/*++
|
|
|
|
Copyright (c) 1995 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ifmgr.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the interface management functions
|
|
|
|
Author:
|
|
|
|
Stefan Solomon 03/06/1995
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
//
|
|
//*** Interface Manager Globals ***
|
|
//
|
|
|
|
// Counter of existing interfaces
|
|
|
|
ULONG InterfaceCount = 0;
|
|
|
|
|
|
//
|
|
//*** Interface Manager APIs ***
|
|
//
|
|
|
|
typedef struct _IF_TYPE_TRANSLATION {
|
|
|
|
ROUTER_INTERFACE_TYPE DIMInterfaceType;
|
|
ULONG MIBInterfaceType;
|
|
|
|
} IF_TYPE_TRANSLATION, *PIF_TYPE_TRANSLATION;
|
|
|
|
IF_TYPE_TRANSLATION IfTypeTranslation[] = {
|
|
|
|
{ ROUTER_IF_TYPE_FULL_ROUTER, IF_TYPE_WAN_ROUTER },
|
|
{ ROUTER_IF_TYPE_HOME_ROUTER, IF_TYPE_PERSONAL_WAN_ROUTER },
|
|
{ ROUTER_IF_TYPE_DEDICATED, IF_TYPE_LAN },
|
|
{ ROUTER_IF_TYPE_CLIENT, IF_TYPE_WAN_WORKSTATION },
|
|
{ ROUTER_IF_TYPE_INTERNAL, IF_TYPE_INTERNAL }
|
|
|
|
};
|
|
|
|
#define MAX_IF_TRANSLATION_TYPES sizeof(IfTypeTranslation)/sizeof(IF_TYPE_TRANSLATION)
|
|
|
|
/*++
|
|
|
|
Function: AddInterface
|
|
|
|
Descr: Creates the interface control block and adds the specific
|
|
structures of the interface info to the corresponding modules.
|
|
|
|
Arguments:
|
|
InterfaceNamep :
|
|
|
|
Pointer to a WCHAR string representing the interface name.
|
|
|
|
InterfaceInfop :
|
|
|
|
Pointer to an IPX_INFO_BLOCK_HEADER structure containing the
|
|
IPX, RIP and SAP interface information, static routes and static services.
|
|
|
|
Pointer to an IPX_INFO_BLOCK_HEADER structure containing the
|
|
traffic filters.
|
|
|
|
InterfaceType:
|
|
|
|
REMARK: In order for the router to be able to start, the internal interface
|
|
has to be added.
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
AddInterface(
|
|
IN LPWSTR InterfaceNamep,
|
|
IN LPVOID InterfaceInfop,
|
|
// IN LPVOID InFilterInfop,
|
|
// IN LPVOID OutFilterInfop,
|
|
IN ROUTER_INTERFACE_TYPE DIMInterfaceType,
|
|
IN HANDLE hDIMInterface,
|
|
IN OUT PHANDLE phInterface)
|
|
{
|
|
PICB icbp;
|
|
ULONG InterfaceNameLen; // if name length in bytes including wchar NULL
|
|
PIPX_IF_INFO IpxIfInfop;
|
|
PIPX_STATIC_ROUTE_INFO StaticRtInfop;
|
|
PIPX_STATIC_SERVICE_INFO StaticSvInfop;
|
|
PIPXWAN_IF_INFO IpxwanIfInfop;
|
|
PIPX_TRAFFIC_FILTER_GLOBAL_INFO InFltGlInfo, OutFltGlInfo;
|
|
// PUCHAR TrafficFilterInfop;
|
|
PIPX_INFO_BLOCK_HEADER IfInfop = (PIPX_INFO_BLOCK_HEADER)InterfaceInfop;
|
|
PACB acbp;
|
|
ULONG AdapterNameLen = 0; // length of adapter name
|
|
// for ROUTER_IF_TYPE_DEDICATED interface type.
|
|
PIPX_TOC_ENTRY tocep;
|
|
UINT i;
|
|
PIPX_ADAPTER_INFO AdapterInfop;
|
|
ULONG tmp;
|
|
FW_IF_INFO FwIfInfo;
|
|
PIF_TYPE_TRANSLATION ittp;
|
|
ULONG InterfaceIndex;
|
|
PIPX_STATIC_NETBIOS_NAME_INFO StaticNbInfop;
|
|
|
|
Trace(INTERFACE_TRACE, "AddInterface: Entered for interface %S", InterfaceNamep);
|
|
|
|
if(InterfaceInfop == NULL) {
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
RouterLogErrorDataW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_BAD_INTERFACE_CONFIG,
|
|
1, &InterfaceNamep, 0, NULL);
|
|
}
|
|
Trace(INTERFACE_TRACE, "AddInterface: Missing interface info for interface %ls\n", InterfaceNamep);
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
// interface name length including the unicode null
|
|
InterfaceNameLen = (wcslen(InterfaceNamep) + 1) * sizeof(WCHAR);
|
|
|
|
// If the interface type if ROUTER_IF_TYPE_DEDICATED (LAN Adapter) we parse the
|
|
// interface name to extract the adapter name and the packet type.
|
|
// The packet type will be then converted to an integer and the two will
|
|
// be used to identify a corresponding adapter.
|
|
|
|
if(DIMInterfaceType == ROUTER_IF_TYPE_DEDICATED) {
|
|
PWCHAR pszStart, pszEnd;
|
|
DWORD dwGuidLength = 37;
|
|
|
|
// get the lan adapter specific info from the interface
|
|
if((AdapterInfop = (PIPX_ADAPTER_INFO)GetInfoEntry(InterfaceInfop,
|
|
IPX_ADAPTER_INFO_TYPE)) == NULL)
|
|
{
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
RouterLogErrorDataW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_BAD_INTERFACE_CONFIG,
|
|
1, &InterfaceNamep, 0, NULL);
|
|
}
|
|
Trace(INTERFACE_TRACE, "AddInterface: Dedicated interface %ls missing adapter info\n", InterfaceNamep);
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
// If the supplied adater is a reference to a guid, then use the name
|
|
// of the guid supplied in the interface name. This is because load/save
|
|
// config's can cause these two to get out of sync.
|
|
pszStart = wcsstr (InterfaceNamep, L"{");
|
|
pszEnd = wcsstr (InterfaceNamep, L"}");
|
|
if ( (pszStart) &&
|
|
(pszEnd) &&
|
|
(pszStart == InterfaceNamep) &&
|
|
((DWORD)(pszEnd - pszStart) == dwGuidLength) )
|
|
{
|
|
wcsncpy (AdapterInfop->AdapterName, InterfaceNamep, dwGuidLength);
|
|
}
|
|
|
|
AdapterNameLen = (wcslen(AdapterInfop->AdapterName) + 1) * sizeof(WCHAR);
|
|
}
|
|
|
|
ACQUIRE_DATABASE_LOCK;
|
|
|
|
if(RouterOperState != OPER_STATE_UP) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
// Check if this is the internal interface. If it is and if we
|
|
// already have the internal interface, we return an error
|
|
if((DIMInterfaceType == ROUTER_IF_TYPE_INTERNAL) &&
|
|
(InternalInterfacep)) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
// internal interface already exists
|
|
Trace(INTERFACE_TRACE, "AddInterface: INTERNAL interface already exists\n");
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
// Allocate a new ICB and initialize it
|
|
// we allocate the interface and adapter name buffers at the end of the
|
|
// ICB struct.
|
|
if((icbp = (PICB)GlobalAlloc(GPTR,
|
|
sizeof(ICB) +
|
|
InterfaceNameLen +
|
|
AdapterNameLen)) == NULL) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
// can't alloc memory
|
|
SS_ASSERT(FALSE);
|
|
|
|
return ERROR_OUT_OF_STRUCTURES;
|
|
}
|
|
|
|
// signature
|
|
memcpy(&icbp->Signature, InterfaceSignature, 4);
|
|
|
|
// get a new index and increment the global interface index counter
|
|
// if this is not the internal interface. For the internal interface we
|
|
// have reserved index 0
|
|
if(DIMInterfaceType == ROUTER_IF_TYPE_INTERNAL) {
|
|
|
|
icbp->InterfaceIndex = 0;
|
|
}
|
|
else
|
|
{
|
|
icbp->InterfaceIndex = GetNextInterfaceIndex();
|
|
if(icbp->InterfaceIndex == MAX_INTERFACE_INDEX) {
|
|
|
|
GlobalFree(icbp);
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
}
|
|
|
|
InterfaceIndex = icbp->InterfaceIndex;
|
|
|
|
|
|
// copy the interface name
|
|
icbp->InterfaceNamep = (PWSTR)((PUCHAR)icbp + sizeof(ICB));
|
|
memcpy(icbp->InterfaceNamep, InterfaceNamep, InterfaceNameLen);
|
|
|
|
// copy the adapter name and packet type if dedicated interface
|
|
if(DIMInterfaceType == ROUTER_IF_TYPE_DEDICATED) {
|
|
|
|
icbp->AdapterNamep = (PWSTR)((PUCHAR)icbp + sizeof(ICB) + InterfaceNameLen);
|
|
wcscpy(icbp->AdapterNamep, AdapterInfop->AdapterName);
|
|
icbp->PacketType = AdapterInfop->PacketType;
|
|
}
|
|
else
|
|
{
|
|
icbp->AdapterNamep = NULL;
|
|
icbp->PacketType = 0;
|
|
}
|
|
|
|
// insert the if in the index hash table
|
|
AddIfToDB(icbp);
|
|
|
|
// get the if handle used when calling DIM entry points
|
|
icbp->hDIMInterface = hDIMInterface;
|
|
|
|
// reset the update status fields
|
|
ResetUpdateRequest(icbp);
|
|
|
|
// mark connection not requested yet
|
|
icbp->ConnectionRequestPending = FALSE;
|
|
|
|
// get to the interface entries in the interface info block
|
|
if(((IpxIfInfop = (PIPX_IF_INFO)GetInfoEntry(InterfaceInfop, IPX_INTERFACE_INFO_TYPE)) == NULL) ||
|
|
((IpxwanIfInfop = (PIPXWAN_IF_INFO)GetInfoEntry(InterfaceInfop, IPXWAN_INTERFACE_INFO_TYPE)) == NULL)) {
|
|
|
|
RemoveIfFromDB(icbp);
|
|
GlobalFree(icbp);
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
// don't have all ipx or ipxwan interfaces info
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
RouterLogErrorDataW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_BAD_INTERFACE_CONFIG,
|
|
1, &InterfaceNamep, 0, NULL);
|
|
}
|
|
Trace(INTERFACE_TRACE, "AddInterface: missing ipx or ipxwan interface info\n");
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
// Initialize the Admin State and the Oper State of this interface.
|
|
// Oper State may be changed will be changed later to OPER_STATE_SLEEPING
|
|
// if this is a WAN interface.
|
|
icbp->OperState = OPER_STATE_DOWN;
|
|
|
|
// set the DIM interface type of this ICB
|
|
icbp->DIMInterfaceType = DIMInterfaceType;
|
|
|
|
// set the MIB interface type of this ICB
|
|
icbp->MIBInterfaceType = IF_TYPE_OTHER;
|
|
for(i=0, ittp=IfTypeTranslation; i<MAX_IF_TRANSLATION_TYPES; i++, ittp++) {
|
|
|
|
if(icbp->DIMInterfaceType == ittp->DIMInterfaceType) {
|
|
|
|
icbp->MIBInterfaceType = ittp->MIBInterfaceType;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// create the routing protocols (rip/sap or nlsp) interface info
|
|
// If the routing protocols interface info is missing this will fail
|
|
if(CreateRoutingProtocolsInterfaces(InterfaceInfop, icbp) != NO_ERROR) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
// don't have all rip and sap interfaces info
|
|
Trace(INTERFACE_TRACE, "AddInterface: Bad routing protocols interface config info\n");
|
|
|
|
goto ErrorExit;
|
|
}
|
|
|
|
// create the Forwarder interface
|
|
FwIfInfo.NetbiosAccept = IpxIfInfop->NetbiosAccept;
|
|
FwIfInfo.NetbiosDeliver = IpxIfInfop->NetbiosDeliver;
|
|
FwCreateInterface(icbp->InterfaceIndex,
|
|
MapIpxToNetInterfaceType(icbp),
|
|
&FwIfInfo);
|
|
|
|
// Seed the traffic filters
|
|
if ((tocep = GetTocEntry(InterfaceInfop, IPX_IN_TRAFFIC_FILTER_INFO_TYPE))!=NULL) {
|
|
|
|
if ((InFltGlInfo = GetInfoEntry(InterfaceInfop, IPX_IN_TRAFFIC_FILTER_GLOBAL_INFO_TYPE)) == NULL) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
RouterLogErrorDataW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_BAD_INTERFACE_CONFIG,
|
|
1, &InterfaceNamep, 0, NULL);
|
|
}
|
|
Trace(INTERFACE_TRACE, "AddInterface: Bad input filters config info");
|
|
|
|
goto ErrorExit;
|
|
}
|
|
|
|
if (SetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_INBOUND,
|
|
InFltGlInfo->FilterAction, // pass or don't pass
|
|
tocep->InfoSize, // filter size
|
|
(LPBYTE)InterfaceInfop+tocep->Offset,
|
|
tocep->InfoSize*tocep->Count) != NO_ERROR) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
RouterLogErrorDataW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_BAD_INTERFACE_CONFIG,
|
|
1, &InterfaceNamep, 0, NULL);
|
|
}
|
|
Trace(INTERFACE_TRACE, "AddInterface: Bad input filters config info");
|
|
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
else { // No Filters -> delete all
|
|
if (SetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_INBOUND, // in or outbound,
|
|
0, // pass or don't pass
|
|
0, // filter size
|
|
NULL,
|
|
0)!=NO_ERROR) {
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
Trace(INTERFACE_TRACE, "AddInterface: Could not delete input filters");
|
|
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
if ((tocep = GetTocEntry(InterfaceInfop, IPX_OUT_TRAFFIC_FILTER_INFO_TYPE))!=NULL) {
|
|
|
|
if ((OutFltGlInfo = GetInfoEntry(InterfaceInfop, IPX_OUT_TRAFFIC_FILTER_GLOBAL_INFO_TYPE)) == NULL) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
Trace(INTERFACE_TRACE, "AddInterface: Bad output filters config info");
|
|
|
|
goto ErrorExit;
|
|
}
|
|
|
|
if (SetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_OUTBOUND,
|
|
OutFltGlInfo->FilterAction, // pass or don't pass
|
|
tocep->InfoSize, // filter size
|
|
(LPBYTE)InterfaceInfop+tocep->Offset,
|
|
tocep->InfoSize*tocep->Count) != NO_ERROR) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
RouterLogErrorDataW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_BAD_INTERFACE_CONFIG,
|
|
1, &InterfaceNamep, 0, NULL);
|
|
}
|
|
Trace(INTERFACE_TRACE, "AddInterface: Bad output filters config info");
|
|
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
else { // No Filters -> delete all
|
|
if (SetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_OUTBOUND, // in or outbound,
|
|
0, // pass or don't pass
|
|
0, // filter size
|
|
NULL,
|
|
0)!=NO_ERROR) {
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
Trace(INTERFACE_TRACE, "AddInterface: Could not delete output filters");
|
|
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
// mark the interface reachable
|
|
icbp->InterfaceReachable = TRUE;
|
|
|
|
// set the admin state
|
|
if(IpxIfInfop->AdminState == ADMIN_STATE_ENABLED) {
|
|
|
|
AdminEnable(icbp);
|
|
}
|
|
else
|
|
{
|
|
AdminDisable(icbp);
|
|
}
|
|
|
|
// seed the static routes
|
|
if(DIMInterfaceType!=ROUTER_IF_TYPE_CLIENT) {
|
|
if (tocep = GetTocEntry(InterfaceInfop, IPX_STATIC_ROUTE_INFO_TYPE)) {
|
|
|
|
StaticRtInfop = (PIPX_STATIC_ROUTE_INFO)GetInfoEntry(InterfaceInfop,
|
|
IPX_STATIC_ROUTE_INFO_TYPE);
|
|
|
|
for(i=0; i<tocep->Count; i++, StaticRtInfop++) {
|
|
|
|
CreateStaticRoute(icbp, StaticRtInfop);
|
|
}
|
|
}
|
|
|
|
// seed the static services
|
|
if(tocep = GetTocEntry(InterfaceInfop, IPX_STATIC_SERVICE_INFO_TYPE)) {
|
|
|
|
StaticSvInfop = (PIPX_STATIC_SERVICE_INFO)GetInfoEntry(InterfaceInfop,
|
|
IPX_STATIC_SERVICE_INFO_TYPE);
|
|
|
|
for(i=0; i<tocep->Count; i++, StaticSvInfop++) {
|
|
|
|
CreateStaticService(icbp, StaticSvInfop);
|
|
}
|
|
}
|
|
|
|
// seed the static netbios names
|
|
if(tocep = GetTocEntry(InterfaceInfop, IPX_STATIC_NETBIOS_NAME_INFO_TYPE)) {
|
|
|
|
StaticNbInfop = (PIPX_STATIC_NETBIOS_NAME_INFO)GetInfoEntry(InterfaceInfop,
|
|
IPX_STATIC_NETBIOS_NAME_INFO_TYPE);
|
|
|
|
FwSetStaticNetbiosNames(icbp->InterfaceIndex,
|
|
tocep->Count,
|
|
StaticNbInfop);
|
|
}
|
|
}
|
|
|
|
// set the IPXWAN interface info
|
|
icbp->EnableIpxWanNegotiation = IpxwanIfInfop->AdminState;
|
|
|
|
// mark the interface as unbound to an adapter (default)
|
|
icbp->acbp = NULL;
|
|
|
|
// check if we can bind it now to an adapter. We can do this only for a
|
|
// a dedicated (LAN) interface or for an internal interface.
|
|
|
|
switch(icbp->DIMInterfaceType) {
|
|
|
|
case ROUTER_IF_TYPE_DEDICATED:
|
|
// Only bind interface if internal interface is already
|
|
// created and bound
|
|
if (InternalInterfacep && InternalInterfacep->acbp) {
|
|
// check if we have an adapter with a corresponding name and
|
|
// packet type
|
|
if((acbp = GetAdapterByNameAndPktType (icbp->AdapterNamep,
|
|
icbp->PacketType)) != NULL) {
|
|
|
|
BindInterfaceToAdapter(icbp, acbp);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case ROUTER_IF_TYPE_INTERNAL:
|
|
|
|
// get the pointer to the internal interface
|
|
InternalInterfacep = icbp;
|
|
|
|
// check that we have the adapter with adapter index 0 which
|
|
// represents the internal adapter
|
|
if(InternalAdapterp) {
|
|
PLIST_ENTRY lep;
|
|
acbp = InternalAdapterp;
|
|
|
|
BindInterfaceToAdapter(icbp, acbp);
|
|
lep = IndexIfList.Flink;
|
|
// Bind all previously added dedicated interfaces that were
|
|
// not bound awaiting for internal interface to be added
|
|
while(lep != &IndexIfList) {
|
|
PACB acbp2;
|
|
PICB icbp2 = CONTAINING_RECORD(lep, ICB, IndexListLinkage);
|
|
lep = lep->Flink;
|
|
switch(icbp2->DIMInterfaceType) {
|
|
case ROUTER_IF_TYPE_DEDICATED:
|
|
// check if we have an adapter with a corresponding name and
|
|
// packet type
|
|
if ((icbp2->acbp==NULL)
|
|
&&((acbp2 = GetAdapterByNameAndPktType (icbp2->AdapterNamep,
|
|
icbp2->PacketType)) != NULL)) {
|
|
|
|
BindInterfaceToAdapter(icbp2, acbp2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (icbp->AdminState==ADMIN_STATE_ENABLED)
|
|
// this is a WAN interface. As long as it isn't connected, and
|
|
// enabled the oper state will be sleeping on this interface
|
|
icbp->OperState = OPER_STATE_SLEEPING;
|
|
break;
|
|
|
|
}
|
|
|
|
// increment the interface counter
|
|
InterfaceCount++;
|
|
|
|
switch(icbp->DIMInterfaceType)
|
|
{
|
|
|
|
case ROUTER_IF_TYPE_DEDICATED:
|
|
|
|
if(icbp->acbp) {
|
|
|
|
Trace(INTERFACE_TRACE, "AddInterface: created LAN interface: # %d name %ls bound to adapter # %d name %ls\n",
|
|
icbp->InterfaceIndex,
|
|
icbp->InterfaceNamep,
|
|
icbp->acbp->AdapterIndex,
|
|
icbp->AdapterNamep);
|
|
}
|
|
else
|
|
{
|
|
Trace(INTERFACE_TRACE, "AddInterface: created LAN interface: # %d name %ls unbound to any adapter\n",
|
|
icbp->InterfaceIndex,
|
|
icbp->InterfaceNamep);
|
|
}
|
|
|
|
break;
|
|
|
|
case ROUTER_IF_TYPE_INTERNAL:
|
|
|
|
if(icbp->acbp) {
|
|
|
|
Trace(INTERFACE_TRACE, "AddInterface: created INTERNAL interface: # %d name %ls bound to internal adapter\n",
|
|
icbp->InterfaceIndex,
|
|
icbp->InterfaceNamep);
|
|
}
|
|
else
|
|
{
|
|
Trace(INTERFACE_TRACE, "AddInterface: created INTERNAL interface: # %d name %ls unbound to any adapter\n",
|
|
icbp->InterfaceIndex,
|
|
icbp->InterfaceNamep);
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
Trace(INTERFACE_TRACE, "AddInterface: created WAN interface: # %d name %ls\n",
|
|
icbp->InterfaceIndex,
|
|
icbp->InterfaceNamep);
|
|
break;
|
|
|
|
}
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
// return the allocated if index
|
|
*phInterface = (HANDLE)UlongToPtr(icbp->InterfaceIndex);
|
|
return NO_ERROR;
|
|
|
|
ErrorExit:
|
|
|
|
InterfaceCount++;
|
|
|
|
DeleteInterface((HANDLE)UlongToPtr(InterfaceIndex));
|
|
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function: DeleteInterface
|
|
Descr:
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
DeleteInterface(HANDLE InterfaceIndex)
|
|
{
|
|
PICB icbp;
|
|
|
|
Trace(INTERFACE_TRACE, "DeleteInterface: Entered for interface # %d\n",
|
|
InterfaceIndex);
|
|
|
|
ACQUIRE_DATABASE_LOCK;
|
|
|
|
if(RouterOperState != OPER_STATE_UP) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
icbp = GetInterfaceByIndex(PtrToUlong(InterfaceIndex));
|
|
|
|
if(icbp == NULL) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if(memcmp(&icbp->Signature, InterfaceSignature, 4)) {
|
|
|
|
// not a valid if pointer
|
|
SS_ASSERT(FALSE);
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
// if bound to an adapter -> unbind
|
|
if(icbp->acbp) {
|
|
|
|
UnbindInterfaceFromAdapter(icbp);
|
|
}
|
|
|
|
// delete the routing protocols interfaces
|
|
DeleteRoutingProtocolsInterfaces(icbp->InterfaceIndex);
|
|
|
|
// delete all static routes from RTM
|
|
DeleteAllStaticRoutes(icbp->InterfaceIndex);
|
|
|
|
DeleteAllStaticServices(icbp->InterfaceIndex);
|
|
|
|
// delete the Fw interface. This will delete all associated filters
|
|
FwDeleteInterface(icbp->InterfaceIndex);
|
|
|
|
// remove the if from the data base
|
|
RemoveIfFromDB(icbp);
|
|
|
|
// done
|
|
GlobalFree(icbp);
|
|
|
|
// decrement the interface counter
|
|
InterfaceCount--;
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
Trace(INTERFACE_TRACE, "DeleteInterface: Deleted interface %d\n", InterfaceIndex);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Function: GetInterfaceInfo
|
|
Descr:
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
GetInterfaceInfo(
|
|
IN HANDLE InterfaceIndex,
|
|
OUT LPVOID InterfaceInfop,
|
|
IN OUT DWORD *InterfaceInfoSize
|
|
// OUT LPVOID InFilterInfo,
|
|
// IN OUT DWORD *InFilterInfoSize,
|
|
// OUT LPVOID OutFilterInfo,
|
|
// IN OUT DWORD *OutFilterInfoSize
|
|
)
|
|
{
|
|
PICB icbp;
|
|
PIPX_INFO_BLOCK_HEADER ibhp, fbhp;
|
|
PIPX_TOC_ENTRY tocep;
|
|
PIPX_IF_INFO IpxIfInfop;
|
|
PIPX_STATIC_ROUTE_INFO StaticRtInfop;
|
|
PIPX_STATIC_SERVICE_INFO StaticSvInfop;
|
|
PIPXWAN_IF_INFO IpxwanIfInfop;
|
|
PIPX_ADAPTER_INFO IpxAdapterInfop;
|
|
PIPX_TRAFFIC_FILTER_GLOBAL_INFO InFltGlInfo, OutFltGlInfo;
|
|
ULONG InFltAction, OutFltAction;
|
|
ULONG InFltSize, OutFltSize;
|
|
ULONG InFltInfoSize=0, OutFltInfoSize=0;
|
|
FW_IF_STATS FwIfStats;
|
|
ULONG iftoccount = 0;
|
|
ULONG ifinfolen = 0;
|
|
ULONG NextInfoOffset;
|
|
ULONG IpxIfOffset = 0;
|
|
ULONG StaticRtOffset = 0;
|
|
ULONG StaticSvOffset = 0;
|
|
IPX_STATIC_ROUTE_INFO StaticRoute;
|
|
UINT i;
|
|
HANDLE EnumHandle;
|
|
FW_IF_INFO FwIfInfo;
|
|
ULONG StaticRoutesCount, StaticServicesCount, TrafficFiltersCount;
|
|
DWORD rc;
|
|
PIPX_STATIC_NETBIOS_NAME_INFO NetbiosNamesInfop;
|
|
ULONG NetbiosNamesCount = 0;
|
|
|
|
Trace(INTERFACE_TRACE, "GetInterfaceInfo: Entered for interface # %d\n", InterfaceIndex);
|
|
|
|
ACQUIRE_DATABASE_LOCK;
|
|
|
|
if(RouterOperState != OPER_STATE_UP) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
if((icbp = GetInterfaceByIndex(PtrToUlong(InterfaceIndex))) == NULL) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
Trace(INTERFACE_TRACE, "GetInterfaceInfo: Nonexistent interface with # %d\n", InterfaceIndex);
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
SS_ASSERT(!memcmp(&icbp->Signature, InterfaceSignature, 4));
|
|
|
|
// calculate the minimum number of toc entries we should have:
|
|
// ipx toc entry
|
|
// routing protocols toc entries
|
|
// ipxwan toc entry
|
|
iftoccount = 2 + RoutingProtocolsTocCount();
|
|
|
|
// if this is a lan adapter, it should also have adapter info
|
|
if(icbp->DIMInterfaceType == ROUTER_IF_TYPE_DEDICATED) {
|
|
|
|
iftoccount++;
|
|
}
|
|
|
|
// calculate the minimun length of the interface info block
|
|
ifinfolen = sizeof(IPX_INFO_BLOCK_HEADER) +
|
|
(iftoccount - 1) * sizeof(IPX_TOC_ENTRY) +
|
|
sizeof(IPX_IF_INFO) +
|
|
SizeOfRoutingProtocolsIfsInfo(PtrToUlong(InterfaceIndex)) +
|
|
sizeof(IPXWAN_IF_INFO);
|
|
|
|
// if this is a lan adapter, add the size of the adapter info
|
|
if(icbp->DIMInterfaceType == ROUTER_IF_TYPE_DEDICATED) {
|
|
|
|
ifinfolen += sizeof(IPX_ADAPTER_INFO);
|
|
}
|
|
|
|
if(StaticRoutesCount = GetStaticRoutesCount(icbp->InterfaceIndex)) {
|
|
|
|
ifinfolen += sizeof(IPX_TOC_ENTRY) +
|
|
StaticRoutesCount * sizeof(IPX_STATIC_ROUTE_INFO);
|
|
|
|
iftoccount++;
|
|
}
|
|
|
|
if(StaticServicesCount = GetStaticServicesCount(icbp->InterfaceIndex)) {
|
|
|
|
ifinfolen += sizeof(IPX_TOC_ENTRY) +
|
|
StaticServicesCount * sizeof(IPX_STATIC_SERVICE_INFO);
|
|
|
|
iftoccount++;
|
|
}
|
|
|
|
FwGetStaticNetbiosNames(icbp->InterfaceIndex,
|
|
&NetbiosNamesCount,
|
|
NULL);
|
|
|
|
if(NetbiosNamesCount) {
|
|
|
|
ifinfolen += sizeof(IPX_TOC_ENTRY) +
|
|
NetbiosNamesCount * sizeof(IPX_STATIC_NETBIOS_NAME_INFO);
|
|
|
|
iftoccount++;
|
|
}
|
|
|
|
|
|
// get the length of the filters info
|
|
rc = GetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_INBOUND,
|
|
&InFltAction,
|
|
&InFltSize,
|
|
NULL,
|
|
&InFltInfoSize);
|
|
|
|
if((rc != NO_ERROR) && (rc != ERROR_INSUFFICIENT_BUFFER)) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return rc;
|
|
}
|
|
|
|
if (InFltInfoSize>0) {
|
|
ifinfolen += sizeof (IPX_TOC_ENTRY)*2 + InFltInfoSize
|
|
+ sizeof (IPX_TRAFFIC_FILTER_GLOBAL_INFO);
|
|
iftoccount += 2;
|
|
}
|
|
|
|
rc = GetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_OUTBOUND,
|
|
&OutFltAction,
|
|
&OutFltSize,
|
|
NULL,
|
|
&OutFltInfoSize);
|
|
|
|
if((rc != NO_ERROR) && (rc != ERROR_INSUFFICIENT_BUFFER)) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return rc;
|
|
}
|
|
|
|
if (OutFltInfoSize>0) {
|
|
ifinfolen += sizeof (IPX_TOC_ENTRY)*2 + OutFltInfoSize
|
|
+ sizeof (IPX_TRAFFIC_FILTER_GLOBAL_INFO);
|
|
iftoccount += 2;
|
|
}
|
|
// check if we have valid and sufficient buffers
|
|
if((InterfaceInfop == NULL) ||
|
|
(ifinfolen > *InterfaceInfoSize)) {
|
|
|
|
*InterfaceInfoSize = ifinfolen;
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
return ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
|
|
*InterfaceInfoSize = ifinfolen;
|
|
|
|
|
|
//
|
|
// Start filling in the interface info block
|
|
//
|
|
|
|
// start of the info block
|
|
ibhp = (PIPX_INFO_BLOCK_HEADER)InterfaceInfop;
|
|
|
|
// offset of the first INFO entry
|
|
NextInfoOffset = sizeof(IPX_INFO_BLOCK_HEADER) +
|
|
(iftoccount -1) * sizeof(IPX_TOC_ENTRY);
|
|
|
|
ibhp->Version = IPX_ROUTER_VERSION_1;
|
|
ibhp->Size = ifinfolen;
|
|
ibhp->TocEntriesCount = iftoccount;
|
|
|
|
tocep = ibhp->TocEntry;
|
|
|
|
// ipx if toc entry
|
|
tocep->InfoType = IPX_INTERFACE_INFO_TYPE;
|
|
tocep->InfoSize = sizeof(IPX_IF_INFO);
|
|
tocep->Count = 1;
|
|
tocep->Offset = NextInfoOffset;
|
|
NextInfoOffset += tocep->Count * tocep->InfoSize;
|
|
|
|
// ipx if info entry
|
|
IpxIfInfop = (PIPX_IF_INFO)((PUCHAR)ibhp + tocep->Offset);
|
|
|
|
IpxIfInfop->AdminState = icbp->AdminState;
|
|
|
|
FwGetInterface(icbp->InterfaceIndex,
|
|
&FwIfInfo,
|
|
&FwIfStats);
|
|
|
|
IpxIfInfop->NetbiosAccept = FwIfInfo.NetbiosAccept;
|
|
IpxIfInfop->NetbiosDeliver = FwIfInfo.NetbiosDeliver;
|
|
|
|
// create the toc and info entries for the routing protocols in the
|
|
// ouput buffer; this function will update the current TOC entry pointer
|
|
// value (tocep) and the current next entry info offset value (nextInfoOffset)
|
|
if((rc = CreateRoutingProtocolsTocAndInfoEntries(ibhp,
|
|
icbp->InterfaceIndex,
|
|
&tocep,
|
|
&NextInfoOffset)) != NO_ERROR) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return rc;
|
|
}
|
|
|
|
// ipxwan if toc entry
|
|
tocep++;
|
|
tocep->InfoType = IPXWAN_INTERFACE_INFO_TYPE;
|
|
tocep->InfoSize = sizeof(IPXWAN_IF_INFO);
|
|
tocep->Count = 1;
|
|
tocep->Offset = NextInfoOffset;
|
|
NextInfoOffset += tocep->Count * tocep->InfoSize;
|
|
|
|
// ipxwan if info entry
|
|
IpxwanIfInfop = (PIPXWAN_IF_INFO)((PUCHAR)ibhp + tocep->Offset);
|
|
|
|
IpxwanIfInfop->AdminState = icbp->EnableIpxWanNegotiation;
|
|
|
|
// if this is a lan interface, fill in the adapter info
|
|
if(icbp->DIMInterfaceType == ROUTER_IF_TYPE_DEDICATED) {
|
|
|
|
// ipx adapter toc entry
|
|
tocep++;
|
|
tocep->InfoType = IPX_ADAPTER_INFO_TYPE;
|
|
tocep->InfoSize = sizeof(IPX_ADAPTER_INFO);
|
|
|
|
tocep->Count = 1;
|
|
tocep->Offset = NextInfoOffset;
|
|
NextInfoOffset += tocep->Count * tocep->InfoSize;
|
|
|
|
// ipx adapter info entry
|
|
IpxAdapterInfop = (PIPX_ADAPTER_INFO)((PUCHAR)ibhp + tocep->Offset);
|
|
|
|
IpxAdapterInfop->PacketType = icbp->PacketType;
|
|
wcscpy(IpxAdapterInfop->AdapterName, icbp->AdapterNamep);
|
|
}
|
|
|
|
// static routes toc + info entries
|
|
if(StaticRoutesCount) {
|
|
|
|
// static routes toc entry
|
|
tocep++;
|
|
tocep->InfoType = IPX_STATIC_ROUTE_INFO_TYPE;
|
|
tocep->InfoSize = sizeof(IPX_STATIC_ROUTE_INFO);
|
|
tocep->Count = StaticRoutesCount;
|
|
tocep->Offset = NextInfoOffset;
|
|
NextInfoOffset += tocep->Count * tocep->InfoSize;
|
|
|
|
// Create static routes enumeration handle for this interface
|
|
EnumHandle = CreateStaticRoutesEnumHandle(icbp->InterfaceIndex);
|
|
|
|
for(i=0, StaticRtInfop = (PIPX_STATIC_ROUTE_INFO)((PUCHAR)ibhp + tocep->Offset);
|
|
i<StaticRoutesCount;
|
|
i++, StaticRtInfop++) {
|
|
|
|
GetNextStaticRoute(EnumHandle, StaticRtInfop);
|
|
}
|
|
|
|
// Close the enumeration handle
|
|
CloseStaticRoutesEnumHandle(EnumHandle);
|
|
}
|
|
|
|
// static services toc + info entries
|
|
if(StaticServicesCount) {
|
|
|
|
// static services toc entry
|
|
tocep++;
|
|
tocep->InfoType = IPX_STATIC_SERVICE_INFO_TYPE;
|
|
tocep->InfoSize = sizeof(IPX_STATIC_SERVICE_INFO);
|
|
tocep->Count = StaticServicesCount;
|
|
tocep->Offset = NextInfoOffset;
|
|
NextInfoOffset += tocep->Count * tocep->InfoSize;
|
|
|
|
// Create static services enumeration handle for this interface
|
|
EnumHandle = CreateStaticServicesEnumHandle(icbp->InterfaceIndex);
|
|
|
|
for(i=0, StaticSvInfop = (PIPX_STATIC_SERVICE_INFO)((PUCHAR)ibhp + tocep->Offset);
|
|
i<StaticServicesCount;
|
|
i++, StaticSvInfop++) {
|
|
|
|
GetNextStaticService(EnumHandle, StaticSvInfop);
|
|
}
|
|
|
|
// Close the enumeration handle
|
|
CloseStaticServicesEnumHandle(EnumHandle);
|
|
}
|
|
|
|
// static netbios names toc + info entries
|
|
if(NetbiosNamesCount) {
|
|
|
|
// static netbios names toc entry
|
|
tocep++;
|
|
tocep->InfoType = IPX_STATIC_NETBIOS_NAME_INFO_TYPE;
|
|
tocep->InfoSize = sizeof(IPX_STATIC_NETBIOS_NAME_INFO);
|
|
tocep->Count = NetbiosNamesCount;
|
|
tocep->Offset = NextInfoOffset;
|
|
NextInfoOffset += tocep->Count * tocep->InfoSize;
|
|
|
|
NetbiosNamesInfop = (PIPX_STATIC_NETBIOS_NAME_INFO)((PUCHAR)ibhp + tocep->Offset);
|
|
|
|
rc = FwGetStaticNetbiosNames(icbp->InterfaceIndex,
|
|
&NetbiosNamesCount,
|
|
NetbiosNamesInfop);
|
|
|
|
if(rc != NO_ERROR) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
if(InFltInfoSize) {
|
|
|
|
// traffic filter input global info
|
|
tocep++;
|
|
tocep->InfoType = IPX_IN_TRAFFIC_FILTER_GLOBAL_INFO_TYPE;
|
|
tocep->InfoSize = sizeof(IPX_TRAFFIC_FILTER_GLOBAL_INFO);
|
|
tocep->Count = 1;
|
|
tocep->Offset = NextInfoOffset;
|
|
NextInfoOffset += tocep->Count * tocep->InfoSize;
|
|
|
|
InFltGlInfo = (PIPX_TRAFFIC_FILTER_GLOBAL_INFO)((PUCHAR)ibhp + tocep->Offset);
|
|
|
|
|
|
rc = GetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_INBOUND,
|
|
&InFltAction,
|
|
&InFltSize,
|
|
(LPBYTE)InterfaceInfop+NextInfoOffset,
|
|
&InFltInfoSize);
|
|
if(rc != NO_ERROR) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return rc;
|
|
}
|
|
|
|
InFltGlInfo->FilterAction = InFltAction;
|
|
|
|
// traffic filter input global info
|
|
tocep++;
|
|
tocep->InfoType = IPX_IN_TRAFFIC_FILTER_INFO_TYPE;
|
|
tocep->InfoSize = InFltSize;
|
|
tocep->Count = InFltInfoSize/InFltSize;
|
|
tocep->Offset = NextInfoOffset;
|
|
NextInfoOffset += tocep->Count * tocep->InfoSize;
|
|
}
|
|
|
|
if(OutFltInfoSize) {
|
|
|
|
// traffic filter input global info
|
|
tocep++;
|
|
tocep->InfoType = IPX_OUT_TRAFFIC_FILTER_GLOBAL_INFO_TYPE;
|
|
tocep->InfoSize = sizeof(IPX_TRAFFIC_FILTER_GLOBAL_INFO);
|
|
tocep->Count = 1;
|
|
tocep->Offset = NextInfoOffset;
|
|
NextInfoOffset += tocep->Count * tocep->InfoSize;
|
|
|
|
OutFltGlInfo = (PIPX_TRAFFIC_FILTER_GLOBAL_INFO)((PUCHAR)ibhp + tocep->Offset);
|
|
|
|
|
|
rc = GetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_OUTBOUND,
|
|
&OutFltAction,
|
|
&OutFltSize,
|
|
(LPBYTE)InterfaceInfop+NextInfoOffset,
|
|
&OutFltInfoSize);
|
|
if(rc != NO_ERROR) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return rc;
|
|
}
|
|
|
|
OutFltGlInfo->FilterAction = OutFltAction;
|
|
|
|
// traffic filter input global info
|
|
tocep++;
|
|
tocep->InfoType = IPX_OUT_TRAFFIC_FILTER_INFO_TYPE;
|
|
tocep->InfoSize = OutFltSize;
|
|
tocep->Count = OutFltInfoSize/OutFltSize;
|
|
tocep->Offset = NextInfoOffset;
|
|
NextInfoOffset += tocep->Count * tocep->InfoSize;
|
|
}
|
|
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Function: SetInterfaceInfo
|
|
Descr:
|
|
|
|
--*/
|
|
|
|
|
|
DWORD
|
|
SetInterfaceInfo(
|
|
IN HANDLE InterfaceIndex,
|
|
IN LPVOID InterfaceInfop)
|
|
{
|
|
PICB icbp;
|
|
PIPX_IF_INFO IpxIfInfop;
|
|
PIPXWAN_IF_INFO IpxwanIfInfop;
|
|
PIPX_STATIC_ROUTE_INFO NewStaticRtInfop;
|
|
PIPX_STATIC_SERVICE_INFO NewStaticSvInfop;
|
|
PIPX_INFO_BLOCK_HEADER IfInfop = (PIPX_INFO_BLOCK_HEADER)InterfaceInfop;
|
|
PIPX_TOC_ENTRY tocep;
|
|
DWORD rc = NO_ERROR;
|
|
HANDLE EnumHandle;
|
|
FW_IF_INFO FwIfInfo;
|
|
PIPX_STATIC_NETBIOS_NAME_INFO StaticNbInfop;
|
|
PIPX_TRAFFIC_FILTER_GLOBAL_INFO InFltGlInfo, OutFltGlInfo;
|
|
|
|
ACQUIRE_DATABASE_LOCK;
|
|
|
|
if(RouterOperState != OPER_STATE_UP) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
|
|
if((icbp = GetInterfaceByIndex(PtrToUlong(InterfaceIndex))) == NULL) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
SS_ASSERT(!memcmp(&icbp->Signature, InterfaceSignature, 4));
|
|
|
|
// check if there was a change in the interface info block
|
|
if(IfInfop == NULL) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
// check that we have all the mandatory info blocks
|
|
if(((IpxIfInfop = (PIPX_IF_INFO)GetInfoEntry(InterfaceInfop, IPX_INTERFACE_INFO_TYPE)) == NULL) ||
|
|
((IpxwanIfInfop = (PIPXWAN_IF_INFO)GetInfoEntry(InterfaceInfop, IPXWAN_INTERFACE_INFO_TYPE)) == NULL)) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
// invalid info
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if(SetRoutingProtocolsInterfaces(InterfaceInfop,
|
|
icbp->InterfaceIndex) != NO_ERROR) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
// invalid info
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
// set ipx if info changes
|
|
if(icbp->AdminState != IpxIfInfop->AdminState) {
|
|
|
|
if(IpxIfInfop->AdminState == ADMIN_STATE_ENABLED) {
|
|
|
|
AdminEnable(icbp);
|
|
}
|
|
else
|
|
{
|
|
AdminDisable(icbp);
|
|
}
|
|
}
|
|
|
|
FwIfInfo.NetbiosAccept = IpxIfInfop->NetbiosAccept;
|
|
FwIfInfo.NetbiosDeliver = IpxIfInfop->NetbiosDeliver;
|
|
|
|
FwSetInterface(icbp->InterfaceIndex, &FwIfInfo);
|
|
|
|
// set IPXWAN info changes
|
|
icbp->EnableIpxWanNegotiation = IpxwanIfInfop->AdminState;
|
|
|
|
// set static routes
|
|
if((tocep = GetTocEntry(InterfaceInfop, IPX_STATIC_ROUTE_INFO_TYPE)) == NULL) {
|
|
|
|
// no static routes
|
|
// delete them if we've got them
|
|
if(GetStaticRoutesCount(icbp->InterfaceIndex)) {
|
|
|
|
DeleteAllStaticRoutes(icbp->InterfaceIndex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// delete non-present ones and add new ones
|
|
NewStaticRtInfop = (PIPX_STATIC_ROUTE_INFO)GetInfoEntry(InterfaceInfop, IPX_STATIC_ROUTE_INFO_TYPE);
|
|
|
|
// Create static routes enumeration handle for this interface
|
|
EnumHandle = CreateStaticRoutesEnumHandle(icbp->InterfaceIndex);
|
|
|
|
if(UpdateStaticIfEntries(icbp,
|
|
EnumHandle,
|
|
sizeof(IPX_STATIC_ROUTE_INFO),
|
|
tocep->Count, // number of routes in the new info
|
|
NewStaticRtInfop,
|
|
GetNextStaticRoute,
|
|
DeleteStaticRoute,
|
|
CreateStaticRoute)) {
|
|
|
|
// Close the enumeration handle
|
|
CloseStaticRoutesEnumHandle(EnumHandle);
|
|
|
|
rc = ERROR_GEN_FAILURE;
|
|
goto UpdateFailure;
|
|
}
|
|
|
|
// Close the enumeration handle
|
|
CloseStaticRoutesEnumHandle(EnumHandle);
|
|
}
|
|
|
|
// set static services
|
|
if((tocep = GetTocEntry(InterfaceInfop, IPX_STATIC_SERVICE_INFO_TYPE)) == NULL) {
|
|
|
|
// no static services
|
|
// delete them if we've got them
|
|
if(GetStaticServicesCount(icbp->InterfaceIndex)) {
|
|
|
|
DeleteAllStaticServices(icbp->InterfaceIndex);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// delete non-present ones and add new ones
|
|
NewStaticSvInfop = (PIPX_STATIC_SERVICE_INFO)GetInfoEntry(InterfaceInfop, IPX_STATIC_SERVICE_INFO_TYPE);
|
|
|
|
// Create static services enumeration handle for this interface
|
|
EnumHandle = CreateStaticServicesEnumHandle(icbp->InterfaceIndex);
|
|
|
|
if(UpdateStaticIfEntries(icbp,
|
|
EnumHandle,
|
|
sizeof(IPX_STATIC_SERVICE_INFO),
|
|
tocep->Count, // number of services in the new info
|
|
NewStaticSvInfop,
|
|
GetNextStaticService,
|
|
DeleteStaticService,
|
|
CreateStaticService)) {
|
|
|
|
|
|
// Close the enumeration handle
|
|
CloseStaticServicesEnumHandle(EnumHandle);
|
|
|
|
rc = ERROR_GEN_FAILURE;
|
|
goto UpdateFailure;
|
|
}
|
|
|
|
// Close the enumeration handle
|
|
CloseStaticServicesEnumHandle(EnumHandle);
|
|
}
|
|
|
|
// set static netbios names
|
|
if((tocep = GetTocEntry(InterfaceInfop, IPX_STATIC_NETBIOS_NAME_INFO_TYPE)) == NULL) {
|
|
|
|
// no static netbios names
|
|
FwSetStaticNetbiosNames(icbp->InterfaceIndex,
|
|
0,
|
|
NULL);
|
|
}
|
|
else
|
|
{
|
|
// set the new ones
|
|
StaticNbInfop = (PIPX_STATIC_NETBIOS_NAME_INFO)GetInfoEntry(InterfaceInfop,
|
|
IPX_STATIC_NETBIOS_NAME_INFO_TYPE);
|
|
|
|
FwSetStaticNetbiosNames(icbp->InterfaceIndex,
|
|
tocep->Count,
|
|
StaticNbInfop);
|
|
}
|
|
|
|
// Seed the traffic filters
|
|
if ((tocep = GetTocEntry(InterfaceInfop, IPX_IN_TRAFFIC_FILTER_INFO_TYPE))!=NULL) {
|
|
|
|
if ((InFltGlInfo = GetInfoEntry(InterfaceInfop, IPX_IN_TRAFFIC_FILTER_GLOBAL_INFO_TYPE)) == NULL) {
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
RouterLogErrorDataW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_BAD_INTERFACE_CONFIG,
|
|
1, &icbp->InterfaceNamep, 0, NULL);
|
|
}
|
|
Trace(INTERFACE_TRACE, "SetInterface: Bad input filters config info");
|
|
|
|
goto UpdateFailure;
|
|
}
|
|
|
|
if (SetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_INBOUND,
|
|
InFltGlInfo->FilterAction, // pass or don't pass
|
|
tocep->InfoSize, // filter size
|
|
(LPBYTE)InterfaceInfop+tocep->Offset,
|
|
tocep->InfoSize*tocep->Count) != NO_ERROR) {
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
RouterLogErrorDataW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_BAD_INTERFACE_CONFIG,
|
|
1, &icbp->InterfaceNamep, 0, NULL);
|
|
}
|
|
Trace(INTERFACE_TRACE, "SetInterface: Bad input filters config info");
|
|
|
|
goto UpdateFailure;
|
|
}
|
|
}
|
|
else { // No Filters -> delete all
|
|
if (SetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_INBOUND, // in or outbound,
|
|
0, // pass or don't pass
|
|
0, // filter size
|
|
NULL,
|
|
0)!=NO_ERROR) {
|
|
|
|
Trace(INTERFACE_TRACE, "SetInterface: Could not delete input filters");
|
|
|
|
goto UpdateFailure;
|
|
}
|
|
}
|
|
|
|
if ((tocep = GetTocEntry(InterfaceInfop, IPX_OUT_TRAFFIC_FILTER_INFO_TYPE))!=NULL) {
|
|
|
|
if ((OutFltGlInfo = GetInfoEntry(InterfaceInfop, IPX_OUT_TRAFFIC_FILTER_GLOBAL_INFO_TYPE)) == NULL) {
|
|
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
RouterLogErrorDataW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_BAD_INTERFACE_CONFIG,
|
|
1, &icbp->InterfaceNamep, 0, NULL);
|
|
}
|
|
Trace(INTERFACE_TRACE, "SetInterface: Bad output filters config info");
|
|
|
|
goto UpdateFailure;
|
|
}
|
|
|
|
if (SetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_OUTBOUND,
|
|
OutFltGlInfo->FilterAction, // pass or don't pass
|
|
tocep->InfoSize, // filter size
|
|
(LPBYTE)InterfaceInfop+tocep->Offset,
|
|
tocep->InfoSize*tocep->Count) != NO_ERROR) {
|
|
|
|
IF_LOG (EVENTLOG_ERROR_TYPE) {
|
|
RouterLogErrorDataW (RMEventLogHdl,
|
|
ROUTERLOG_IPX_BAD_INTERFACE_CONFIG,
|
|
1, &icbp->InterfaceNamep, 0, NULL);
|
|
}
|
|
Trace(INTERFACE_TRACE, "SetInterface: Bad output filters config info");
|
|
|
|
goto UpdateFailure;
|
|
}
|
|
}
|
|
else { // No Filters -> delete all
|
|
if (SetFilters(icbp->InterfaceIndex,
|
|
IPX_TRAFFIC_FILTER_OUTBOUND, // in or outbound,
|
|
0, // pass or don't pass
|
|
0, // filter size
|
|
NULL,
|
|
0)!=NO_ERROR) {
|
|
Trace(INTERFACE_TRACE, "SetInterface: Could not delete output filters");
|
|
|
|
goto UpdateFailure;
|
|
}
|
|
}
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
return NO_ERROR;
|
|
|
|
UpdateFailure:
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return rc;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function: InterfaceNotReachable
|
|
|
|
Descr: Called in the following cases:
|
|
|
|
1. Following a ConnectInterface request from the Router Manager,
|
|
to indicate that the connection atempt has failed.
|
|
|
|
2. When DIM realizes it won't be able to execute any further
|
|
ConnectInterface requests because of out of resources.
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
InterfaceNotReachable(
|
|
IN HANDLE InterfaceIndex,
|
|
IN UNREACHABILITY_REASON Reason)
|
|
{
|
|
PICB icbp;
|
|
|
|
Trace(INTERFACE_TRACE, "IpxRM: InterfaceNotReachable: Entered for if # %d\n",
|
|
InterfaceIndex);
|
|
|
|
ACQUIRE_DATABASE_LOCK;
|
|
|
|
if(RouterOperState != OPER_STATE_UP) {
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
|
|
if((icbp = GetInterfaceByIndex(PtrToUlong(InterfaceIndex))) == NULL) {
|
|
|
|
// interface has been removed
|
|
RELEASE_DATABASE_LOCK;
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if(icbp->ConnectionRequestPending) {
|
|
|
|
icbp->ConnectionRequestPending = FALSE;
|
|
|
|
// notify the forwarder of the connection failure
|
|
FwConnectionRequestFailed(icbp->InterfaceIndex);
|
|
}
|
|
|
|
// if there is reason to stop advertising routes/services on this if
|
|
// because it can't be reached in the future, do it!
|
|
|
|
if(icbp->InterfaceReachable)
|
|
{
|
|
icbp->InterfaceReachable = FALSE;
|
|
|
|
// stop advertising static routes on this interface
|
|
DisableStaticRoutes(icbp->InterfaceIndex);
|
|
|
|
// disable the interface for all routing prot and fw
|
|
// this will stop advertising any static services
|
|
ExternalDisableInterface(icbp->InterfaceIndex);
|
|
}
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function: InterfaceReachable
|
|
|
|
Descr: Called by DIM following a previous InterfaceNotReachable to
|
|
indicate that conditions are met to do connections on this if.
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
InterfaceReachable(
|
|
IN HANDLE InterfaceIndex)
|
|
{
|
|
PICB icbp;
|
|
|
|
Trace(INTERFACE_TRACE, "IpxRM: InterfaceReachable: Entered for if # %d\n",
|
|
InterfaceIndex);
|
|
|
|
ACQUIRE_DATABASE_LOCK;
|
|
if(RouterOperState != OPER_STATE_UP) {
|
|
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
if((icbp = GetInterfaceByIndex(PtrToUlong(InterfaceIndex))) == NULL) {
|
|
|
|
// interface has been removed
|
|
RELEASE_DATABASE_LOCK;
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if(!icbp->InterfaceReachable) {
|
|
|
|
icbp->InterfaceReachable = TRUE;
|
|
|
|
if(icbp->AdminState == ADMIN_STATE_ENABLED) {
|
|
|
|
// enable all static routes for this interface
|
|
EnableStaticRoutes(icbp->InterfaceIndex);
|
|
|
|
// enable external interfaces. Implicitly, this will enable static services
|
|
// bound to this interface to be advertised
|
|
ExternalEnableInterface(icbp->InterfaceIndex);
|
|
}
|
|
}
|
|
|
|
RELEASE_DATABASE_LOCK;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD APIENTRY
|
|
InterfaceConnected (
|
|
IN HANDLE hInterface,
|
|
IN PVOID pFilter,
|
|
IN PVOID pPppProjectionResult
|
|
) {
|
|
return NO_ERROR;
|
|
}
|
|
|
|
VOID
|
|
DestroyAllInterfaces(VOID)
|
|
{
|
|
PICB icbp;
|
|
|
|
while(!IsListEmpty(&IndexIfList)) {
|
|
|
|
icbp = CONTAINING_RECORD(IndexIfList.Flink, ICB, IndexListLinkage);
|
|
|
|
// remove the if from the data base
|
|
RemoveIfFromDB(icbp);
|
|
|
|
Trace(INTERFACE_TRACE, "DestroyAllInterfaces: destroyed interface %d\n", icbp->InterfaceIndex);
|
|
|
|
GlobalFree(icbp);
|
|
|
|
// decrement the interface counter
|
|
InterfaceCount--;
|
|
}
|
|
}
|