1625 lines
36 KiB
C++
1625 lines
36 KiB
C++
/*++
|
||
|
||
Copyright (c) 2000, Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
ftpif.c
|
||
|
||
Abstract:
|
||
|
||
This module contains code for the FTP transparent proxy's interface
|
||
management.
|
||
|
||
Author:
|
||
|
||
Qiang Wang (qiangw) 10-April-2000
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "precomp.h"
|
||
#pragma hdrstop
|
||
#include <ipnatapi.h>
|
||
|
||
//
|
||
// GLOBAL DATA DEFINITIONS
|
||
//
|
||
|
||
LIST_ENTRY FtpInterfaceList;
|
||
CRITICAL_SECTION FtpInterfaceLock;
|
||
ULONG FtpFirewallIfCount;
|
||
|
||
|
||
ULONG
|
||
FtpAcceptConnectionInterface(
|
||
IN PFTP_INTERFACE Interfacep,
|
||
IN SOCKET ListeningSocket,
|
||
IN SOCKET AcceptedSocket OPTIONAL,
|
||
IN PNH_BUFFER Bufferp OPTIONAL,
|
||
OUT PHANDLE DynamicRedirectHandlep OPTIONAL
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to accept a connection on an interface. It issues
|
||
an accept-request on the socket and optionally issues a redirect to cause
|
||
FTP control-channel connection-requests to be sent to the listening
|
||
socket.
|
||
|
||
Arguments:
|
||
|
||
Interfacep - the interface on which to accept a connection
|
||
|
||
ListeningSocket - the socket on which to listen for a connection
|
||
|
||
AcceptedSocket - optionally specifies the socket with which to accept
|
||
a connection.
|
||
|
||
Bufferp - optionally supplies a buffer to be used for accept-data
|
||
|
||
DynamicRedirectHandlep - on output, optionally receives a handle to a
|
||
dynamic redirect created for the interface. The dynamic redirect
|
||
is only created if the caller specifies this parameter.
|
||
|
||
Return Value:
|
||
|
||
ULONG - Win32/Winsock2 status code.
|
||
|
||
Notes:
|
||
|
||
Invoked with the interface's lock held by the caller and with a reference
|
||
made to the interface on behalf of the accept-completion routine. It is
|
||
this routine's responsibility to release that reference in the event of a
|
||
failure.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG Address;
|
||
ULONG Error;
|
||
USHORT Port;
|
||
|
||
PROFILE("FtpAcceptConnectionInterface");
|
||
|
||
Error =
|
||
NhAcceptStreamSocket(
|
||
&FtpComponentReference,
|
||
ListeningSocket,
|
||
AcceptedSocket,
|
||
Bufferp,
|
||
FtpAcceptCompletionRoutine,
|
||
Interfacep,
|
||
(PVOID)ListeningSocket
|
||
);
|
||
if (Error) {
|
||
FTP_DEREFERENCE_INTERFACE(Interfacep);
|
||
NhTrace(
|
||
TRACE_FLAG_FTP,
|
||
"FtpAcceptConnectionInterface: error %d accepting connection",
|
||
Error
|
||
);
|
||
} else if (DynamicRedirectHandlep) {
|
||
|
||
//
|
||
// From here onward, failures do not require us to drop our reference
|
||
// to the interface, since it is now guaranteed that the accept-
|
||
// completion routine will be invoked.
|
||
//
|
||
// Create the dynamic redirect which will cause all FTP control
|
||
// channel connections to our listening socket.
|
||
//
|
||
|
||
Error = NhQueryLocalEndpointSocket(ListeningSocket, &Address, &Port);
|
||
if (Error) {
|
||
NhTrace(
|
||
TRACE_FLAG_FTP,
|
||
"FtpAcceptConnectionInterface: error %d querying endpoint",
|
||
Error
|
||
);
|
||
} else {
|
||
|
||
//
|
||
// Install redirect(s).
|
||
//
|
||
|
||
if (NAT_IFC_PRIVATE(Interfacep->Characteristics) ||
|
||
FTP_INTERFACE_MAPPED(Interfacep)) {
|
||
|
||
ASSERT(!FTP_INTERFACE_MAPPED(Interfacep) ||
|
||
NAT_IFC_BOUNDARY(Interfacep->Characteristics));
|
||
|
||
Error =
|
||
NatCreateDynamicAdapterRestrictedPortRedirect(
|
||
NatRedirectFlagReceiveOnly,
|
||
NAT_PROTOCOL_TCP,
|
||
FTP_PORT_CONTROL,
|
||
Address,
|
||
Port,
|
||
Interfacep->AdapterIndex,
|
||
0,
|
||
&DynamicRedirectHandlep[0]
|
||
);
|
||
NhTrace(
|
||
TRACE_FLAG_FTP,
|
||
"FtpAcceptConnectionInterface:"
|
||
" redirect installed for adapter 0x%08x [%d]",
|
||
Interfacep->AdapterIndex,
|
||
Error
|
||
);
|
||
}
|
||
|
||
if (!Error && NAT_IFC_FW(Interfacep->Characteristics)) {
|
||
Error =
|
||
NatCreateDynamicAdapterRestrictedPortRedirect(
|
||
NatRedirectFlagSendOnly,
|
||
NAT_PROTOCOL_TCP,
|
||
FTP_PORT_CONTROL,
|
||
Address,
|
||
Port,
|
||
Interfacep->AdapterIndex,
|
||
0,
|
||
&DynamicRedirectHandlep[1]
|
||
);
|
||
|
||
NhTrace(
|
||
TRACE_FLAG_FTP,
|
||
"FtpAcceptConnectionInterface:"
|
||
" redirect installed for firewalled adapter 0x%08x [%d]",
|
||
Interfacep->AdapterIndex,
|
||
Error
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
return Error;
|
||
} // FtpAcceptConnectionInterface
|
||
|
||
|
||
ULONG
|
||
FtpActivateInterface(
|
||
PFTP_INTERFACE Interfacep
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to activate an interface, when the interface
|
||
becomes both enabled and bound.
|
||
Activation involves
|
||
(a) creating sockets for each binding of the interface
|
||
(b) initiating connection-acceptance on each created socket
|
||
(c) initiating session-redirection for the FTP port, if necessary.
|
||
|
||
Arguments:
|
||
|
||
Interfacep - the interface to be activated
|
||
|
||
Return Value:
|
||
|
||
ULONG - Win32 status code indicating success or failure.
|
||
|
||
Notes:
|
||
|
||
Always invoked locally, with 'Interfacep' referenced by caller and/or
|
||
'FtpInterfaceLock' held by caller.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG Error;
|
||
ULONG i;
|
||
BOOLEAN IsNatInterface;
|
||
|
||
PROFILE("FtpActivateInterface");
|
||
|
||
EnterCriticalSection(&FtpInterfaceLock);
|
||
if (FTP_INTERFACE_ADMIN_DISABLED(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
return NO_ERROR;
|
||
}
|
||
|
||
Interfacep->Characteristics
|
||
= NatGetInterfaceCharacteristics(Interfacep->Index);
|
||
|
||
if (!Interfacep->Characteristics) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_FTP,
|
||
"FtpActivateInterface: ignoring non-NAT interface %d",
|
||
Interfacep->Index
|
||
);
|
||
return NO_ERROR;
|
||
}
|
||
|
||
if (NAT_IFC_BOUNDARY(Interfacep->Characteristics)) {
|
||
for (i = 0; i < Interfacep->BindingCount; i++) {
|
||
Error = NatLookupPortMappingAdapter(
|
||
Interfacep->AdapterIndex,
|
||
NAT_PROTOCOL_TCP,
|
||
Interfacep->BindingArray[i].Address,
|
||
FTP_PORT_CONTROL,
|
||
&Interfacep->PortMapping
|
||
);
|
||
|
||
if (!Error) {
|
||
Interfacep->Flags |= FTP_INTERFACE_FLAG_MAPPED;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (Error && !NAT_IFC_FW(Interfacep->Characteristics)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_FTP,
|
||
"FtpActivateInterface:"
|
||
" ignoring non-FW and non-mapped NAT boundary interface %d",
|
||
Interfacep->Index
|
||
);
|
||
NhWarningLog(
|
||
IP_FTP_LOG_NAT_INTERFACE_IGNORED,
|
||
0,
|
||
"%d",
|
||
Interfacep->Index
|
||
);
|
||
return NO_ERROR;
|
||
}
|
||
}
|
||
|
||
if (NAT_IFC_FW(Interfacep->Characteristics)) {
|
||
InterlockedIncrement(reinterpret_cast<LPLONG>(&FtpFirewallIfCount));
|
||
}
|
||
|
||
//
|
||
// Create stream sockets that listen for connection-requests on each
|
||
// logical network, and datagram sockets that process incoming messages.
|
||
//
|
||
|
||
Error = NO_ERROR;
|
||
|
||
ACQUIRE_LOCK(Interfacep);
|
||
|
||
for (i = 0; i < Interfacep->BindingCount; i++) {
|
||
Error =
|
||
NhCreateStreamSocket(
|
||
Interfacep->BindingArray[i].Address,
|
||
0,
|
||
&Interfacep->BindingArray[i].ListeningSocket
|
||
);
|
||
if (Error) { break; }
|
||
Error = listen(Interfacep->BindingArray[i].ListeningSocket, SOMAXCONN);
|
||
if (Error == SOCKET_ERROR) { break; }
|
||
}
|
||
|
||
//
|
||
// If an error occurred, roll back all work done so far and fail.
|
||
//
|
||
|
||
if (Error) {
|
||
ULONG FailedAddress = i;
|
||
for (--i; (LONG)i >= 0; i--) {
|
||
NhDeleteStreamSocket(
|
||
Interfacep->BindingArray[i].ListeningSocket
|
||
);
|
||
Interfacep->BindingArray[i].ListeningSocket = INVALID_SOCKET;
|
||
}
|
||
NhErrorLog(
|
||
IP_FTP_LOG_ACTIVATE_FAILED,
|
||
Error,
|
||
"%I",
|
||
Interfacep->BindingArray[FailedAddress].Address
|
||
);
|
||
RELEASE_LOCK(Interfacep);
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
return Error;
|
||
}
|
||
|
||
//
|
||
// Initiate connection-acceptance and message-redirection on each socket
|
||
//
|
||
|
||
for (i = 0; i < Interfacep->BindingCount; i++) {
|
||
if (!FTP_REFERENCE_INTERFACE(Interfacep)) { break; }
|
||
Error =
|
||
FtpAcceptConnectionInterface(
|
||
Interfacep,
|
||
Interfacep->BindingArray[i].ListeningSocket,
|
||
INVALID_SOCKET,
|
||
NULL,
|
||
&Interfacep->BindingArray[i].ListeningRedirectHandle[0]
|
||
);
|
||
if (Error) {
|
||
NhErrorLog(
|
||
IP_FTP_LOG_ACCEPT_FAILED,
|
||
Error,
|
||
"%I",
|
||
Interfacep->BindingArray[i].Address
|
||
);
|
||
Error = NO_ERROR;
|
||
}
|
||
}
|
||
|
||
RELEASE_LOCK(Interfacep);
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
|
||
return NO_ERROR;
|
||
|
||
} // FtpActivateInterface
|
||
|
||
|
||
ULONG
|
||
FtpBindInterface(
|
||
ULONG Index,
|
||
PIP_ADAPTER_BINDING_INFO BindingInfo
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is invoked to supply the binding for an interface.
|
||
It records the binding information received, and if necessary,
|
||
it activates the interface.
|
||
|
||
Arguments:
|
||
|
||
Index - the index of the interface to be bound
|
||
|
||
BindingInfo - the binding-information for the interface
|
||
|
||
Return Value:
|
||
|
||
ULONG - Win32 status code.
|
||
|
||
Notes:
|
||
|
||
Invoked internally in the context of an IP router-manager thread.
|
||
(See 'RMFTP.C').
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG i;
|
||
ULONG Error = NO_ERROR;
|
||
PFTP_INTERFACE Interfacep;
|
||
|
||
PROFILE("FtpBindInterface");
|
||
|
||
EnterCriticalSection(&FtpInterfaceLock);
|
||
|
||
//
|
||
// Retrieve the interface to be bound
|
||
//
|
||
|
||
Interfacep = FtpLookupInterface(Index, NULL);
|
||
if (Interfacep == NULL) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpBindInterface: interface %d not found",
|
||
Index
|
||
);
|
||
return ERROR_NO_SUCH_INTERFACE;
|
||
}
|
||
|
||
//
|
||
// Make sure the interface isn't already bound
|
||
//
|
||
|
||
if (FTP_INTERFACE_BOUND(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpBindInterface: interface %d is already bound",
|
||
Index
|
||
);
|
||
return ERROR_ADDRESS_ALREADY_ASSOCIATED;
|
||
}
|
||
|
||
//
|
||
// Reference the interface
|
||
//
|
||
|
||
if (!FTP_REFERENCE_INTERFACE(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpBindInterface: interface %d cannot be referenced",
|
||
Index
|
||
);
|
||
return ERROR_INTERFACE_DISABLED;
|
||
}
|
||
|
||
//
|
||
// Update the interface's flags
|
||
//
|
||
|
||
Interfacep->Flags |= FTP_INTERFACE_FLAG_BOUND;
|
||
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
|
||
ACQUIRE_LOCK(Interfacep);
|
||
|
||
//
|
||
// Allocate space for the binding
|
||
//
|
||
|
||
if (!BindingInfo->AddressCount) {
|
||
Interfacep->BindingCount = 0;
|
||
Interfacep->BindingArray = NULL;
|
||
} else {
|
||
Interfacep->BindingArray =
|
||
reinterpret_cast<PFTP_BINDING>(
|
||
NH_ALLOCATE(BindingInfo->AddressCount * sizeof(FTP_BINDING))
|
||
);
|
||
if (!Interfacep->BindingArray) {
|
||
RELEASE_LOCK(Interfacep);
|
||
FTP_DEREFERENCE_INTERFACE(Interfacep);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpBindInterface: allocation failed for interface %d binding",
|
||
Index
|
||
);
|
||
NhErrorLog(
|
||
IP_FTP_LOG_ALLOCATION_FAILED,
|
||
0,
|
||
"%d",
|
||
BindingInfo->AddressCount * sizeof(FTP_BINDING)
|
||
);
|
||
return ERROR_NOT_ENOUGH_MEMORY;
|
||
}
|
||
ZeroMemory(
|
||
Interfacep->BindingArray,
|
||
BindingInfo->AddressCount * sizeof(FTP_BINDING)
|
||
);
|
||
Interfacep->BindingCount = BindingInfo->AddressCount;
|
||
}
|
||
|
||
//
|
||
// Copy the binding
|
||
//
|
||
|
||
for (i = 0; i < BindingInfo->AddressCount; i++) {
|
||
Interfacep->BindingArray[i].Address = BindingInfo->Address[i].Address;
|
||
Interfacep->BindingArray[i].Mask = BindingInfo->Address[i].Mask;
|
||
Interfacep->BindingArray[i].ListeningSocket = INVALID_SOCKET;
|
||
}
|
||
|
||
//
|
||
// Figure out our IP Adapter Index, if we have a valid binding
|
||
//
|
||
|
||
if (Interfacep->BindingCount) {
|
||
Interfacep->AdapterIndex =
|
||
NhMapAddressToAdapter(BindingInfo->Address[0].Address);
|
||
}
|
||
|
||
RELEASE_LOCK(Interfacep);
|
||
|
||
//
|
||
// Activate the interface if necessary
|
||
//
|
||
|
||
if (FTP_INTERFACE_ACTIVE(Interfacep)) {
|
||
Error = FtpActivateInterface(Interfacep);
|
||
}
|
||
|
||
FTP_DEREFERENCE_INTERFACE(Interfacep);
|
||
|
||
return Error;
|
||
|
||
} // FtpBindInterface
|
||
|
||
|
||
VOID
|
||
FtpCleanupInterface(
|
||
PFTP_INTERFACE Interfacep
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is invoked when the very last reference to an interface
|
||
is released, and the interface must be destroyed.
|
||
|
||
Arguments:
|
||
|
||
Interfacep - the interface to be destroyed
|
||
|
||
Return Value:
|
||
|
||
none.
|
||
|
||
Notes:
|
||
|
||
Invoked internally from an arbitrary context, with no references
|
||
to the interface.
|
||
|
||
--*/
|
||
|
||
{
|
||
PROFILE("FtpCleanupInterface");
|
||
|
||
if (Interfacep->BindingArray) {
|
||
NH_FREE(Interfacep->BindingArray);
|
||
Interfacep->BindingArray = NULL;
|
||
}
|
||
|
||
DeleteCriticalSection(&Interfacep->Lock);
|
||
|
||
NH_FREE(Interfacep);
|
||
|
||
} // FtpCleanupInterface
|
||
|
||
|
||
ULONG
|
||
FtpConfigureInterface(
|
||
ULONG Index,
|
||
PIP_FTP_INTERFACE_INFO InterfaceInfo
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to set the configuration for an interface.
|
||
|
||
Arguments:
|
||
|
||
Index - the interface to be configured
|
||
|
||
InterfaceInfo - the new configuration
|
||
|
||
Return Value:
|
||
|
||
ULONG - Win32 status code
|
||
|
||
Notes:
|
||
|
||
Invoked internally in the context of a IP router-manager thread.
|
||
(See 'RMFTP.C').
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG Error;
|
||
PFTP_INTERFACE Interfacep;
|
||
ULONG NewFlags;
|
||
ULONG OldFlags;
|
||
|
||
PROFILE("FtpConfigureInterface");
|
||
|
||
//
|
||
// Retrieve the interface to be configured
|
||
//
|
||
|
||
EnterCriticalSection(&FtpInterfaceLock);
|
||
|
||
Interfacep = FtpLookupInterface(Index, NULL);
|
||
if (Interfacep == NULL) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpConfigureInterface: interface %d not found",
|
||
Index
|
||
);
|
||
return ERROR_NO_SUCH_INTERFACE;
|
||
}
|
||
|
||
//
|
||
// Reference the interface
|
||
//
|
||
|
||
if (!FTP_REFERENCE_INTERFACE(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpConfigureInterface: interface %d cannot be referenced",
|
||
Index
|
||
);
|
||
return ERROR_INTERFACE_DISABLED;
|
||
}
|
||
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
|
||
Error = NO_ERROR;
|
||
|
||
ACQUIRE_LOCK(Interfacep);
|
||
|
||
//
|
||
// Compare the interface's current and new configuration
|
||
//
|
||
|
||
OldFlags = Interfacep->Info.Flags;
|
||
NewFlags =
|
||
(InterfaceInfo
|
||
? (InterfaceInfo->Flags|FTP_INTERFACE_FLAG_CONFIGURED) : 0);
|
||
|
||
Interfacep->Flags &= ~OldFlags;
|
||
Interfacep->Flags |= NewFlags;
|
||
|
||
if (!InterfaceInfo) {
|
||
|
||
ZeroMemory(&Interfacep->Info, sizeof(*InterfaceInfo));
|
||
|
||
//
|
||
// The interface no longer has any information;
|
||
// default to being enabled.
|
||
//
|
||
|
||
if (OldFlags & IP_FTP_INTERFACE_FLAG_DISABLED) {
|
||
|
||
//
|
||
// Activate the interface if necessary
|
||
//
|
||
|
||
if (FTP_INTERFACE_ACTIVE(Interfacep)) {
|
||
RELEASE_LOCK(Interfacep);
|
||
Error = FtpActivateInterface(Interfacep);
|
||
ACQUIRE_LOCK(Interfacep);
|
||
}
|
||
}
|
||
} else {
|
||
|
||
CopyMemory(&Interfacep->Info, InterfaceInfo, sizeof(*InterfaceInfo));
|
||
|
||
//
|
||
// Activate or deactivate the interface if its status changed
|
||
//
|
||
|
||
if ((OldFlags & IP_FTP_INTERFACE_FLAG_DISABLED) &&
|
||
!(NewFlags & IP_FTP_INTERFACE_FLAG_DISABLED)) {
|
||
|
||
//
|
||
// Activate the interface
|
||
//
|
||
|
||
if (FTP_INTERFACE_ACTIVE(Interfacep)) {
|
||
RELEASE_LOCK(Interfacep);
|
||
Error = FtpActivateInterface(Interfacep);
|
||
ACQUIRE_LOCK(Interfacep);
|
||
}
|
||
} else if (!(OldFlags & IP_FTP_INTERFACE_FLAG_DISABLED) &&
|
||
(NewFlags & IP_FTP_INTERFACE_FLAG_DISABLED)) {
|
||
|
||
//
|
||
// Deactivate the interface if necessary
|
||
//
|
||
|
||
if (FTP_INTERFACE_ACTIVE(Interfacep)) {
|
||
RELEASE_LOCK(Interfacep);
|
||
FtpDeactivateInterface(Interfacep);
|
||
ACQUIRE_LOCK(Interfacep);
|
||
}
|
||
}
|
||
}
|
||
|
||
RELEASE_LOCK(Interfacep);
|
||
FTP_DEREFERENCE_INTERFACE(Interfacep);
|
||
|
||
return Error;
|
||
|
||
} // FtpConfigureInterface
|
||
|
||
|
||
ULONG
|
||
FtpCreateInterface(
|
||
ULONG Index,
|
||
NET_INTERFACE_TYPE Type,
|
||
PIP_FTP_INTERFACE_INFO InterfaceInfo,
|
||
OUT PFTP_INTERFACE* InterfaceCreated
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is invoked by the router-manager to add a new interface
|
||
to the FTP transparent proxy.
|
||
|
||
Arguments:
|
||
|
||
Index - the index of the new interface
|
||
|
||
Type - the media type of the new interface
|
||
|
||
InterfaceInfo - the interface's configuration
|
||
|
||
Interfacep - receives the interface created
|
||
|
||
Return Value:
|
||
|
||
ULONG - Win32 error code
|
||
|
||
Notes:
|
||
|
||
Invoked internally in the context of an IP router-manager thread.
|
||
(See 'RMFTP.C').
|
||
|
||
--*/
|
||
|
||
{
|
||
PLIST_ENTRY InsertionPoint;
|
||
PFTP_INTERFACE Interfacep;
|
||
|
||
PROFILE("FtpCreateInterface");
|
||
|
||
EnterCriticalSection(&FtpInterfaceLock);
|
||
|
||
//
|
||
// See if the interface already exists;
|
||
// If not, this obtains the insertion point
|
||
//
|
||
|
||
if (FtpLookupInterface(Index, &InsertionPoint)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpCreateInterface: duplicate index found for %d",
|
||
Index
|
||
);
|
||
return ERROR_INTERFACE_ALREADY_EXISTS;
|
||
}
|
||
|
||
//
|
||
// Allocate a new interface
|
||
//
|
||
|
||
Interfacep =
|
||
reinterpret_cast<PFTP_INTERFACE>(NH_ALLOCATE(sizeof(FTP_INTERFACE)));
|
||
|
||
if (!Interfacep) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF, "FtpCreateInterface: error allocating interface"
|
||
);
|
||
NhErrorLog(
|
||
IP_FTP_LOG_ALLOCATION_FAILED,
|
||
0,
|
||
"%d",
|
||
sizeof(FTP_INTERFACE)
|
||
);
|
||
return ERROR_NOT_ENOUGH_MEMORY;
|
||
}
|
||
|
||
//
|
||
// Initialize the new interface
|
||
//
|
||
|
||
ZeroMemory(Interfacep, sizeof(*Interfacep));
|
||
|
||
__try {
|
||
InitializeCriticalSection(&Interfacep->Lock);
|
||
} __except(EXCEPTION_EXECUTE_HANDLER) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NH_FREE(Interfacep);
|
||
return GetExceptionCode();
|
||
}
|
||
|
||
Interfacep->Index = Index;
|
||
Interfacep->Type = Type;
|
||
if (InterfaceInfo) {
|
||
Interfacep->Flags = InterfaceInfo->Flags|FTP_INTERFACE_FLAG_CONFIGURED;
|
||
CopyMemory(&Interfacep->Info, InterfaceInfo, sizeof(*InterfaceInfo));
|
||
}
|
||
Interfacep->ReferenceCount = 1;
|
||
InitializeListHead(&Interfacep->ConnectionList);
|
||
InitializeListHead(&Interfacep->EndpointList);
|
||
InsertTailList(InsertionPoint, &Interfacep->Link);
|
||
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
|
||
if (InterfaceCreated) { *InterfaceCreated = Interfacep; }
|
||
|
||
return NO_ERROR;
|
||
|
||
} // FtpCreateInterface
|
||
|
||
|
||
VOID
|
||
FtpDeactivateInterface(
|
||
PFTP_INTERFACE Interfacep
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to deactivate an interface.
|
||
It closes all sockets on the interface's bindings (if any).
|
||
|
||
Arguments:
|
||
|
||
Interfacep - the interface to be deactivated
|
||
|
||
Return Value:
|
||
|
||
none.
|
||
|
||
Notes:
|
||
|
||
Always invoked locally, with 'Interfacep' referenced by caller and/or
|
||
'FtpInterfaceLock' held by caller.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG i;
|
||
ULONG j;
|
||
PLIST_ENTRY Link;
|
||
PFTP_CONNECTION Connectionp;
|
||
|
||
PROFILE("FtpDeactivateInterface");
|
||
|
||
ACQUIRE_LOCK(Interfacep);
|
||
|
||
//
|
||
// Stop all network I/O on the interface's logical networks
|
||
//
|
||
|
||
for (i = 0; i < Interfacep->BindingCount; i++) {
|
||
if (Interfacep->BindingArray[i].ListeningSocket != INVALID_SOCKET) {
|
||
NhDeleteStreamSocket(Interfacep->BindingArray[i].ListeningSocket);
|
||
Interfacep->BindingArray[i].ListeningSocket = INVALID_SOCKET;
|
||
}
|
||
for (j = 0; j < 2; j++) {
|
||
if (Interfacep->BindingArray[i].ListeningRedirectHandle[j]) {
|
||
NatCancelDynamicPortRedirect(
|
||
Interfacep->BindingArray[i].ListeningRedirectHandle[j]
|
||
);
|
||
Interfacep->BindingArray[i].ListeningRedirectHandle[j] = NULL;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// Eliminate all connections
|
||
//
|
||
|
||
while (!IsListEmpty(&Interfacep->ConnectionList)) {
|
||
Link = RemoveHeadList(&Interfacep->ConnectionList);
|
||
Connectionp = CONTAINING_RECORD(Link, FTP_CONNECTION, Link);
|
||
FtpDeleteConnection(Connectionp);
|
||
}
|
||
|
||
ASSERT(IsListEmpty(&Interfacep->EndpointList));
|
||
|
||
//
|
||
// If this interface is firewalled, decrement the global count.
|
||
//
|
||
|
||
if (NAT_IFC_FW(Interfacep->Characteristics)) {
|
||
InterlockedDecrement(reinterpret_cast<LPLONG>(&FtpFirewallIfCount));
|
||
}
|
||
|
||
RELEASE_LOCK(Interfacep);
|
||
|
||
} // FtpDeactivateInterface
|
||
|
||
|
||
ULONG
|
||
FtpDeleteInterface(
|
||
ULONG Index
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to delete an interface.
|
||
It drops the reference count on the interface so that the last
|
||
dereferencer will delete the interface, and sets the 'deleted' flag
|
||
so that further references to the interface will fail.
|
||
|
||
Arguments:
|
||
|
||
Index - the index of the interface to be deleted
|
||
|
||
Return Value:
|
||
|
||
ULONG - Win32 status code.
|
||
|
||
Notes:
|
||
|
||
Invoked internally in the context of an IP router-manager thread.
|
||
(See 'RMFTP.C').
|
||
|
||
--*/
|
||
|
||
{
|
||
PFTP_INTERFACE Interfacep;
|
||
|
||
PROFILE("FtpDeleteInterface");
|
||
|
||
//
|
||
// Retrieve the interface to be deleted
|
||
//
|
||
|
||
EnterCriticalSection(&FtpInterfaceLock);
|
||
|
||
Interfacep = FtpLookupInterface(Index, NULL);
|
||
if (Interfacep == NULL) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpDeleteInterface: interface %d not found",
|
||
Index
|
||
);
|
||
return ERROR_NO_SUCH_INTERFACE;
|
||
}
|
||
|
||
//
|
||
// Deactivate the interface
|
||
//
|
||
|
||
FtpDeactivateInterface(Interfacep);
|
||
|
||
//
|
||
// Mark the interface as deleted and take it off the interface list
|
||
//
|
||
|
||
Interfacep->Flags |= FTP_INTERFACE_FLAG_DELETED;
|
||
Interfacep->Flags &= ~FTP_INTERFACE_FLAG_ENABLED;
|
||
RemoveEntryList(&Interfacep->Link);
|
||
|
||
//
|
||
// Drop the reference count; if it is non-zero,
|
||
// the deletion will complete later.
|
||
//
|
||
|
||
if (--Interfacep->ReferenceCount) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpDeleteInterface: interface %d deletion pending",
|
||
Index
|
||
);
|
||
return NO_ERROR;
|
||
}
|
||
|
||
//
|
||
// The reference count is zero, so perform final cleanup
|
||
//
|
||
|
||
FtpCleanupInterface(Interfacep);
|
||
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
|
||
return NO_ERROR;
|
||
|
||
} // FtpDeleteInterface
|
||
|
||
|
||
ULONG
|
||
FtpDisableInterface(
|
||
ULONG Index
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to disable I/O on an interface.
|
||
If the interface is active, it is deactivated.
|
||
|
||
Arguments:
|
||
|
||
Index - the index of the interface to be disabled.
|
||
|
||
Return Value:
|
||
|
||
none.
|
||
|
||
Notes:
|
||
|
||
Invoked internally in the context of an IP router-manager thread.
|
||
(See 'RMFTP.C').
|
||
|
||
--*/
|
||
|
||
{
|
||
PFTP_INTERFACE Interfacep;
|
||
|
||
PROFILE("FtpDisableInterface");
|
||
|
||
//
|
||
// Retrieve the interface to be disabled
|
||
//
|
||
|
||
EnterCriticalSection(&FtpInterfaceLock);
|
||
|
||
Interfacep = FtpLookupInterface(Index, NULL);
|
||
if (Interfacep == NULL) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpDisableInterface: interface %d not found",
|
||
Index
|
||
);
|
||
return ERROR_NO_SUCH_INTERFACE;
|
||
}
|
||
|
||
//
|
||
// Make sure the interface is not already disabled
|
||
//
|
||
|
||
if (!FTP_INTERFACE_ENABLED(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpDisableInterface: interface %d already disabled",
|
||
Index
|
||
);
|
||
return ERROR_INTERFACE_DISABLED;
|
||
}
|
||
|
||
//
|
||
// Reference the interface
|
||
//
|
||
|
||
if (!FTP_REFERENCE_INTERFACE(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpDisableInterface: interface %d cannot be referenced",
|
||
Index
|
||
);
|
||
return ERROR_INTERFACE_DISABLED;
|
||
}
|
||
|
||
//
|
||
// Clear the 'enabled' flag
|
||
//
|
||
|
||
Interfacep->Flags &= ~FTP_INTERFACE_FLAG_ENABLED;
|
||
|
||
//
|
||
// Deactivate the interface, if necessary
|
||
//
|
||
|
||
if (FTP_INTERFACE_BOUND(Interfacep)) {
|
||
FtpDeactivateInterface(Interfacep);
|
||
}
|
||
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
|
||
FTP_DEREFERENCE_INTERFACE(Interfacep);
|
||
|
||
return NO_ERROR;
|
||
|
||
} // FtpDisableInterface
|
||
|
||
|
||
ULONG
|
||
FtpEnableInterface(
|
||
ULONG Index
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to enable I/O on an interface.
|
||
If the interface is already bound, this enabling activates it.
|
||
|
||
Arguments:
|
||
|
||
Index - the index of the interfaec to be enabled
|
||
|
||
Return Value:
|
||
|
||
ULONG - Win32 status code.
|
||
|
||
Notes:
|
||
|
||
Invoked internally in the context of an IP router-manager thread.
|
||
(See 'RMFTP.C').
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG Error = NO_ERROR;
|
||
PFTP_INTERFACE Interfacep;
|
||
|
||
PROFILE("FtpEnableInterface");
|
||
|
||
//
|
||
// Retrieve the interface to be enabled
|
||
//
|
||
|
||
EnterCriticalSection(&FtpInterfaceLock);
|
||
|
||
Interfacep = FtpLookupInterface(Index, NULL);
|
||
if (Interfacep == NULL) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpEnableInterface: interface %d not found",
|
||
Index
|
||
);
|
||
return ERROR_NO_SUCH_INTERFACE;
|
||
}
|
||
|
||
//
|
||
// Make sure the interface is not already enabled
|
||
//
|
||
|
||
if (FTP_INTERFACE_ENABLED(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpEnableInterface: interface %d already enabled",
|
||
Index
|
||
);
|
||
return ERROR_INTERFACE_ALREADY_EXISTS;
|
||
}
|
||
|
||
//
|
||
// Reference the interface
|
||
//
|
||
|
||
if (!FTP_REFERENCE_INTERFACE(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpEnableInterface: interface %d cannot be referenced",
|
||
Index
|
||
);
|
||
return ERROR_INTERFACE_DISABLED;
|
||
}
|
||
|
||
//
|
||
// Set the 'enabled' flag
|
||
//
|
||
|
||
Interfacep->Flags |= FTP_INTERFACE_FLAG_ENABLED;
|
||
|
||
//
|
||
// Activate the interface, if necessary
|
||
//
|
||
|
||
if (FTP_INTERFACE_ACTIVE(Interfacep)) {
|
||
Error = FtpActivateInterface(Interfacep);
|
||
}
|
||
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
|
||
FTP_DEREFERENCE_INTERFACE(Interfacep);
|
||
|
||
return Error;
|
||
|
||
} // FtpEnableInterface
|
||
|
||
|
||
ULONG
|
||
FtpInitializeInterfaceManagement(
|
||
VOID
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to initialize the interface-management module.
|
||
|
||
Arguments:
|
||
|
||
none.
|
||
|
||
Return Value:
|
||
|
||
ULONG - Win32 status code.
|
||
|
||
Notes:
|
||
|
||
Invoked internally in the context of an IP router-manager thread.
|
||
(See 'RMFTP.C').
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG Error = NO_ERROR;
|
||
PROFILE("FtpInitializeInterfaceManagement");
|
||
|
||
InitializeListHead(&FtpInterfaceList);
|
||
__try {
|
||
InitializeCriticalSection(&FtpInterfaceLock);
|
||
} __except(EXCEPTION_EXECUTE_HANDLER) {
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpInitializeInterfaceManagement: exception %d creating lock",
|
||
Error = GetExceptionCode()
|
||
);
|
||
}
|
||
FtpFirewallIfCount = 0;
|
||
|
||
return Error;
|
||
|
||
} // FtpInitializeInterfaceManagement
|
||
|
||
|
||
PFTP_INTERFACE
|
||
FtpLookupInterface(
|
||
ULONG Index,
|
||
OUT PLIST_ENTRY* InsertionPoint OPTIONAL
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to retrieve an interface given its index.
|
||
|
||
Arguments:
|
||
|
||
Index - the index of the interface to be retrieved
|
||
|
||
InsertionPoint - if the interface is not found, optionally receives
|
||
the point where the interface would be inserted in the interface list
|
||
|
||
Return Value:
|
||
|
||
PFTP_INTERFACE - the interface, if found; otherwise, NULL.
|
||
|
||
Notes:
|
||
|
||
Invoked internally from an arbitrary context, with 'FtpInterfaceLock'
|
||
held by caller.
|
||
|
||
--*/
|
||
|
||
{
|
||
PFTP_INTERFACE Interfacep;
|
||
PLIST_ENTRY Link;
|
||
PROFILE("FtpLookupInterface");
|
||
for (Link = FtpInterfaceList.Flink; Link != &FtpInterfaceList;
|
||
Link = Link->Flink) {
|
||
Interfacep = CONTAINING_RECORD(Link, FTP_INTERFACE, Link);
|
||
if (Index > Interfacep->Index) {
|
||
continue;
|
||
} else if (Index < Interfacep->Index) {
|
||
break;
|
||
}
|
||
return Interfacep;
|
||
}
|
||
if (InsertionPoint) { *InsertionPoint = Link; }
|
||
return NULL;
|
||
|
||
} // FtpLookupInterface
|
||
|
||
|
||
ULONG
|
||
FtpQueryInterface(
|
||
ULONG Index,
|
||
PVOID InterfaceInfo,
|
||
PULONG InterfaceInfoSize
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is invoked to retrieve the configuration for an interface.
|
||
|
||
Arguments:
|
||
|
||
Index - the interface to be queried
|
||
|
||
InterfaceInfo - receives the retrieved information
|
||
|
||
InterfaceInfoSize - receives the (required) size of the information
|
||
|
||
Return Value:
|
||
|
||
ULONG - Win32 status code.
|
||
|
||
--*/
|
||
|
||
{
|
||
PFTP_INTERFACE Interfacep;
|
||
|
||
PROFILE("FtpQueryInterface");
|
||
|
||
//
|
||
// Check the caller's buffer size
|
||
//
|
||
|
||
if (!InterfaceInfoSize) { return ERROR_INVALID_PARAMETER; }
|
||
|
||
//
|
||
// Retrieve the interface to be configured
|
||
//
|
||
|
||
EnterCriticalSection(&FtpInterfaceLock);
|
||
|
||
Interfacep = FtpLookupInterface(Index, NULL);
|
||
if (Interfacep == NULL) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpQueryInterface: interface %d not found",
|
||
Index
|
||
);
|
||
return ERROR_NO_SUCH_INTERFACE;
|
||
}
|
||
|
||
//
|
||
// Reference the interface
|
||
//
|
||
|
||
if (!FTP_REFERENCE_INTERFACE(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpQueryInterface: interface %d cannot be referenced",
|
||
Index
|
||
);
|
||
return ERROR_INTERFACE_DISABLED;
|
||
}
|
||
|
||
//
|
||
// See if there is any explicit config on this interface
|
||
//
|
||
|
||
if (!FTP_INTERFACE_CONFIGURED(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
FTP_DEREFERENCE_INTERFACE(Interfacep);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpQueryInterface: interface %d has no configuration",
|
||
Index
|
||
);
|
||
*InterfaceInfoSize = 0;
|
||
return NO_ERROR;
|
||
}
|
||
|
||
//
|
||
// See if there is enough buffer space
|
||
//
|
||
|
||
if (*InterfaceInfoSize < sizeof(IP_FTP_INTERFACE_INFO)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
FTP_DEREFERENCE_INTERFACE(Interfacep);
|
||
*InterfaceInfoSize = sizeof(IP_FTP_INTERFACE_INFO);
|
||
return ERROR_INSUFFICIENT_BUFFER;
|
||
}
|
||
|
||
//
|
||
// Copy the requested data
|
||
//
|
||
|
||
CopyMemory(
|
||
InterfaceInfo,
|
||
&Interfacep->Info,
|
||
sizeof(IP_FTP_INTERFACE_INFO)
|
||
);
|
||
*InterfaceInfoSize = sizeof(IP_FTP_INTERFACE_INFO);
|
||
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
|
||
FTP_DEREFERENCE_INTERFACE(Interfacep);
|
||
|
||
return NO_ERROR;
|
||
|
||
} // FtpQueryInterface
|
||
|
||
|
||
VOID
|
||
FtpShutdownInterfaceManagement(
|
||
VOID
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to shutdown the interface-management module.
|
||
|
||
Arguments:
|
||
|
||
none.
|
||
|
||
Return Value:
|
||
|
||
none.
|
||
|
||
Notes:
|
||
|
||
Invoked in an arbitrary thread context, after all references
|
||
to all interfaces have been released.
|
||
|
||
--*/
|
||
|
||
{
|
||
PFTP_INTERFACE Interfacep;
|
||
PLIST_ENTRY Link;
|
||
PROFILE("FtpShutdownInterfaceManagement");
|
||
while (!IsListEmpty(&FtpInterfaceList)) {
|
||
Link = RemoveHeadList(&FtpInterfaceList);
|
||
Interfacep = CONTAINING_RECORD(Link, FTP_INTERFACE, Link);
|
||
if (FTP_INTERFACE_ACTIVE(Interfacep)) {
|
||
FtpDeactivateInterface(Interfacep);
|
||
}
|
||
FtpCleanupInterface(Interfacep);
|
||
}
|
||
DeleteCriticalSection(&FtpInterfaceLock);
|
||
|
||
} // FtpShutdownInterfaceManagement
|
||
|
||
|
||
VOID
|
||
FtpSignalNatInterface(
|
||
ULONG Index,
|
||
BOOLEAN Boundary
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is invoked upon reconfiguration of a NAT interface.
|
||
Note that this routine may be invoked even when the FTP transparent
|
||
proxy is neither installed nor running; it operates as expected,
|
||
since the global information and lock are always initialized.
|
||
|
||
Upon invocation, the routine activates or deactivates the interface
|
||
depending on whether the NAT is not or is running on the interface,
|
||
respectively.
|
||
|
||
Arguments:
|
||
|
||
Index - the reconfigured interface
|
||
|
||
Boundary - indicates whether the interface is now a boundary interface
|
||
|
||
Return Value:
|
||
|
||
none.
|
||
|
||
Notes:
|
||
|
||
Invoked from an arbitrary context.
|
||
|
||
--*/
|
||
|
||
{
|
||
PFTP_INTERFACE Interfacep;
|
||
|
||
PROFILE("FtpSignalNatInterface");
|
||
|
||
EnterCriticalSection(&FtpGlobalInfoLock);
|
||
if (!FtpGlobalInfo) {
|
||
LeaveCriticalSection(&FtpGlobalInfoLock);
|
||
return;
|
||
}
|
||
LeaveCriticalSection(&FtpGlobalInfoLock);
|
||
EnterCriticalSection(&FtpInterfaceLock);
|
||
Interfacep = FtpLookupInterface(Index, NULL);
|
||
if (Interfacep == NULL) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
return;
|
||
}
|
||
FtpDeactivateInterface(Interfacep);
|
||
if (FTP_INTERFACE_ACTIVE(Interfacep)) {
|
||
FtpActivateInterface(Interfacep);
|
||
}
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
|
||
} // FtpSignalNatInterface
|
||
|
||
|
||
ULONG
|
||
FtpUnbindInterface(
|
||
ULONG Index
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is invoked to revoke the binding on an interface.
|
||
This involves deactivating the interface if it is active.
|
||
|
||
Arguments:
|
||
|
||
Index - the index of the interface to be unbound
|
||
|
||
Return Value:
|
||
|
||
none.
|
||
|
||
Notes:
|
||
|
||
Invoked internally in the context of an IP router-manager thread.
|
||
(See 'RMFTP.C').
|
||
|
||
--*/
|
||
|
||
{
|
||
PFTP_INTERFACE Interfacep;
|
||
|
||
PROFILE("FtpUnbindInterface");
|
||
|
||
//
|
||
// Retrieve the interface to be unbound
|
||
//
|
||
|
||
EnterCriticalSection(&FtpInterfaceLock);
|
||
|
||
Interfacep = FtpLookupInterface(Index, NULL);
|
||
if (Interfacep == NULL) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpUnbindInterface: interface %d not found",
|
||
Index
|
||
);
|
||
return ERROR_NO_SUCH_INTERFACE;
|
||
}
|
||
|
||
//
|
||
// Make sure the interface is not already unbound
|
||
//
|
||
|
||
if (!FTP_INTERFACE_BOUND(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpUnbindInterface: interface %d already unbound",
|
||
Index
|
||
);
|
||
return ERROR_ADDRESS_NOT_ASSOCIATED;
|
||
}
|
||
|
||
//
|
||
// Reference the interface
|
||
//
|
||
|
||
if (!FTP_REFERENCE_INTERFACE(Interfacep)) {
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
NhTrace(
|
||
TRACE_FLAG_IF,
|
||
"FtpUnbindInterface: interface %d cannot be referenced",
|
||
Index
|
||
);
|
||
return ERROR_INTERFACE_DISABLED;
|
||
}
|
||
|
||
//
|
||
// Clear the 'bound' and 'mapped' flag
|
||
//
|
||
|
||
Interfacep->Flags &=
|
||
~(FTP_INTERFACE_FLAG_BOUND | FTP_INTERFACE_FLAG_MAPPED);
|
||
|
||
//
|
||
// Deactivate the interface, if necessary
|
||
//
|
||
|
||
if (FTP_INTERFACE_ENABLED(Interfacep)) {
|
||
FtpDeactivateInterface(Interfacep);
|
||
}
|
||
|
||
LeaveCriticalSection(&FtpInterfaceLock);
|
||
|
||
//
|
||
// Destroy the interface's binding
|
||
//
|
||
|
||
ACQUIRE_LOCK(Interfacep);
|
||
NH_FREE(Interfacep->BindingArray);
|
||
Interfacep->BindingArray = NULL;
|
||
Interfacep->BindingCount = 0;
|
||
RELEASE_LOCK(Interfacep);
|
||
|
||
FTP_DEREFERENCE_INTERFACE(Interfacep);
|
||
return NO_ERROR;
|
||
|
||
} // FtpUnbindInterface
|