windows-xp/Source/XPSP1/NT/com/rpc/runtime/trans/common/protocol.cxx

/*++

Copyright (C) Microsoft Corporation, 1996 - 1999

Module Name:

    Protocol.cxx

Abstract:

    Transport Protocol abstraction used mainly by PnP.
    The following is a brief description of the current RPC PnP mechanism:
    Whenever a non-local transport level object (a socket, or an address) is opened
        for a given protocol, it is added to the list of objects for the given protocol.
        This alllows all objects for a given protocol to be tracked down and closed if
        the protocol is unloaded. By the same token, objects closed are removed from
        the list of the given protocol.
    When a PnP notification arrives, the lower level transport code call into this PnP module
        to tell it that there may be a change of state. For each PnP protocol, the PnP code
        examines whether the protocol is active, and what was its last state. Depending of
        the outcome of this comparison, it will take appropriate action. Here's the finite
        state automaton with the transitions:

        Currently, RPC differentiates between four networking states of each protocol -
            protocol is not loaded, protocol is partially loaded (i.e. it is active, but
            does not have an address on it yet), it is fully loaded (or functional), and
            it is fully loaded and network address change monitoring is required. The
            fully loaded state with address change monitoring may be abbreviated to
            FunctionalMon for the purpose of this document.
            Note that Partially Loaded, and loaded without address are equivalent terms
            for the purpose of this module. Also, note that currently the networking
            code does not allow reloading of a protocol, so some of the code paths will
            never get exercised.
        RPC in turn maintains the following RPC (as opposed to networking) states:
            ProtocolNotLoaded
            ProtocolLoadedWithoutAddress
            ProtocolWasLoadedOrNeedsActivation
            ProtocolLoaded
            ProtocolWasLoadedOrNeedsActivationWithoutAddress
            ProtocolLoadedAndMonitored
        Depending on the last RPC state, and the new networking state, the following changes
            and state transitions are effected:
    If a PnP notification fails asynchronously, the completion port code will call into PnP
        code to try to resubmit the queries.
    Note that the threads on which overlapped WSAIoctl's are submitted are not protected.
        If a thread dies, the IO will fail, and the thread that picks the failure will resubmit
        the WSAIoctl. This strategy allows up to keep the thread pool smaller.

                                    Networking State        Action
RPC State
ProtocolNotLoaded                   NotLoaded               No-op
                                    PartiallyLoaded         Submit a WSAIoctl to be notified
                                                                when the protocol becomes
                                                                functional.
                                                            State = ProtocolLoadedWithoutAddress
                                    Functional              State = ProtocolLoaded
                                    FunctionalMon           Submit address change WSAIoctl.
                                                            State = ProtocolLoadedAndMonitored
ProtocolLoadedWithoutAddress        NotLoaded               Cancel WSAIoctl
                                                            State = ProtocolNotLoaded
                                    PartiallyLoaded         No-op
                                    Functional              CancelWSAIoctl
                                                            State = ProtocolLoaded
                                    FunctionalMon           Submit address change WSAIoctl if necessary
                                                            State = ProtocolLoadedAndMonitored
ProtocolWasLoadedOrNeedsActivation  NotLoaded               No-op
                                    PartiallyLoaded         Submit a WSAIoctl to be notified
                                                                when the protocol becomes
                                                                functional.
                                                            State = ProtocolWasLoadedOrNeedsActivationWithoutAddress
                                    Functional              Restart protocol
                                                            State = ProtocolLoaded
                                    FunctionalMon           Submit address change WSAIoctl.
                                                            State = ProtocolLoadedAndMonitored
ProtocolLoaded                      NotLoaded               Unload protocol
                                                            State = ProtocolWasLoadedOrNeedsActivation
                                    PartiallyLoaded         Invalid
                                    Functional              No-op
                                    FunctionalMon           Invalid transition
ProtocolWasLoadedOrNeedsActivationWithoutAddress     
                                    NotLoaded               Cancel WSAIoctl
                                                            State = ProtocolWasLoadedOrNeedsActivation
                                    PartiallyLoaded         No-op
                                    Functional              Restart protocol
                                                            State = ProtocolLoaded
                                    FunctionalMon           Submit address change WSAIoctl.
                                                            State = ProtocolLoadedAndMonitored
ProtocolLoadedAndMonitored          NotLoaded               Cancel address change WSAIoctl
                                                            Unload protocol
                                                            State = ProtocolWasLoadedOrNeedsActivation
                                    PartiallyLoaded         Resubmit address change WSAIoclt if necessary
                                    Functional              Invalid transition
                                    FunctionalMon           No-op
ProtocolNeedToLoadWhenReady         NotLoaded               No-op
                                    PartiallyLoaded         Submit a WSAIoctl to be notified
                                                                when the protocol becomes
                                                                functional.
                                                            State = ProtocolNeedToLoadWhenReadyWithoutAddress
                                    Functional              Restart protocol
                                                            State = ProtocolLoaded
                                    FunctionalMon           Submit address change WSAIoctl.
                                                            State = ProtocolLoadedAndMonitored
ProtocolNeedToLoadWhenReadyWithoutAddress
                                    NotLoaded               Cancel WSAIoctl
                                                            State = ProtocolNeedToLoadWhenReady
                                    PartiallyLoaded         No-op
                                    Functional              Restart protocol
                                                            State = ProtocolLoaded
                                    FunctionalMon           Submit address change WSAIoctl.
                                                            State = ProtocolLoadedAndMonitored



Author:

    Kamen Moutafov    [KamenM]


Revision History:

    KamenM      12/22/1998   Creation
    KamenM      03/05/1999   Adding state ProtocolLoadedAndMonitored and support for it.
    KamenM      07/17/2000   Adding support for ProtocolWasLoadedOrNeedsActivation/
                                ProtocolWasLoadedOrNeedsActivationWithoutAddress

--*/

#include <precomp.hxx>
#include <Protocol.hxx>

void RPC_ENTRY NullAddressChangeFn( PVOID arg )
{
}

RPC_ADDRESS_CHANGE_FN * AddressChangeFn = NullAddressChangeFn;

#ifdef MAJOR_PNP_DEBUG

const char *ProtocolStateNames[];

#endif

void TransportProtocol::DetectedAsFunctional(PROTOCOL_ID ProtocolId)
{
    if (IsAddressChangeMonitoringOn(ProtocolId))
        {
        EnterCriticalSection(&AddressListLock);

        // monitor functional protocols for address change will
        // set the state
        MonitorFunctionalProtocolForAddressChange(ProtocolId);

        LeaveCriticalSection(&AddressListLock);
        }
    else
        {
        // we also need to take the critical section, and cancel any address change
        // notification (if any), to avoid race between a successful listen making
        // the protocol functional, and the address change notification completing
        EnterCriticalSection(&AddressListLock);
        CancelAddressChangeRequestIfNecessary(FALSE, ProtocolId);
        SetState(ProtocolLoaded, ProtocolId);
        LeaveCriticalSection(&AddressListLock);
        }
}

void TransportProtocol::HandleProtocolChange(IN WSAPROTOCOL_INFO *lpProtocolBuffer,
                                             IN int ProtocolCount,
                                             IN PROTOCOL_ID thisProtocolId)
/*++
Function Name: HandleProtocolChange

Parameters:
    lpProtocolBuffer - an array of WSAPROTOCOL_INFO structures as returned by EnumProtocols
    ProtocolCount - the number of elements in the lpProtocolBuffer array
    thisProtocolId - the ID of the protocol for this object

Description:
    This handles protocol state change for a particular protocol. The function is idempotent - it
    can be called many times safely, regardless of previous calls. It will turn into no-op if
    it is redundant.

Returns:

--*/
{
    int i;
    BOOL fProtocolActive = FALSE;
    const WS_TRANS_INFO *pInfo;

    ASSERT(ProtocolCount >= 0);
    ASSERT(lpProtocolBuffer != NULL);
    ASSERT_TRANSPORT_PROTOCOL_STATE(thisProtocolId);

    if (
#ifdef NETBIOS_ON
        (thisProtocolId == NBF) || (thisProtocolId == NBT) || (thisProtocolId == NBI) ||
#endif

#ifdef NCADG_MQ_ON
        (thisProtocolId == MSMQ) ||
#endif

        (thisProtocolId == CDP)
       )
        return;

    if (IsTrailingProtocol(thisProtocolId))
        return;

    for (i = 0; i < ProtocolCount; i ++)
        {
        // if the enumerated protocol is the current protocol, break out of the loop
        if (MapProtocolId(lpProtocolBuffer[i].iProtocol, lpProtocolBuffer[i].iAddressFamily) == thisProtocolId)
            {
            fProtocolActive = TRUE;
            break;
            }
        }

    pInfo = &WsTransportTable[thisProtocolId];

    switch(State)
        {

        case ProtocolNotLoaded:
        case ProtocolLoadedWithoutAddress:
            // if the protocol was not loaded, but now it is active, attempt to verify
            // it is operational
            if (fProtocolActive)
                {
#ifdef MAJOR_PNP_DEBUG
                if (State == ProtocolNotLoaded)
                    {
                    DbgPrint("Protocol %d was just loaded\n", thisProtocolId);
                    }
#endif
                // If the protocol is not fully functional, we will submit an address change
                // request to get notified when it does
                if (VerifyProtocolIsFunctional(thisProtocolId) == TRUE)
                    {
                    // we succeeded in changing the state of the protocol
                    ASSERT((State == ProtocolLoaded) || (State == ProtocolLoadedAndMonitored));
                    if (IsAddressChangeMonitoringOn(thisProtocolId))
                        {
                        MonitorFunctionalProtocolForAddressChange(thisProtocolId);
                        (*AddressChangeFn)((PVOID) State);
                        }
                    }
#ifdef MAJOR_PNP_DEBUG
                if (State == ProtocolLoadedWithoutAddress)
                    {
                    DbgPrint("Protocol %d was without an address\n", thisProtocolId);
                    }
#endif
                }
            else
                {
                if (State == ProtocolLoadedWithoutAddress)
                    {
                    // a protocol was removed without being fully initialized
                    // cancel the pending query if any, and reset the state to not loaded
                    CancelAddressChangeRequestIfNecessary(TRUE, thisProtocolId);
                    SetState(ProtocolNotLoaded, thisProtocolId);
#ifdef MAJOR_PNP_DEBUG
                    DbgPrint("Protocol %d was removed without being fully initialized\n", thisProtocolId);
#endif
                    }
                // else - don't care. The protocol state is not loaded, and will remain so
                }
            break;

        case ProtocolWasLoadedOrNeedsActivation:
        case ProtocolWasLoadedOrNeedsActivationWithoutAddress:
            if (fProtocolActive)
                {
                // If the protocol is not fully functional, we will submit an address change
                // request to get notified when it does
                if (VerifyProtocolIsFunctional(thisProtocolId))
                    {
                    // if a protocol was loaded, and now is active, restart the addresses on it
                    RestartProtocol(thisProtocolId);
                    if (thisProtocolId == TCP)
                        {
                        GetTransportProtocol(HTTP)->RestartProtocol(HTTP);
                        }

                    // we succeeded in changing the state of the protocol
                    ASSERT(State == ProtocolLoaded);
                    if (IsAddressChangeMonitoringOn(thisProtocolId))
                        {
                        MonitorFunctionalProtocolForAddressChange(thisProtocolId);
                        }
                    }
                }
            else
                {
                // if the protocol was loaded, but it's not active, we don't care;
                // if it was trying to get an address, but then it was unloaded,
                // cancel the request
                if (State == ProtocolWasLoadedOrNeedsActivationWithoutAddress)
                    {
                    CancelAddressChangeRequestIfNecessary(TRUE, thisProtocolId);
                    SetState(ProtocolWasLoadedOrNeedsActivation, thisProtocolId);
#ifdef MAJOR_PNP_DEBUG
                    DbgPrint("Protocol %d was removed without being fully initialized\n", thisProtocolId);
#endif
                    }
                }
            break;

        case ProtocolLoaded:
            ASSERT(IsAddressChangeMonitoringOn(thisProtocolId) == FALSE);
            // if the protocol was loaded, and it is active, we don't need to do anything;
            // if it was loaded, but is not active currently, we need to unload the protocol
            if (!fProtocolActive)
                {
#ifdef MAJOR_PNP_DEBUG
                DbgPrint("Protocol %d was just unloaded\n", thisProtocolId);
#endif
                UnloadProtocol(thisProtocolId);
                if (thisProtocolId == TCP)
                    {
                    GetTransportProtocol(HTTP)->UnloadProtocol(HTTP);
                    }
                SetState(ProtocolWasLoadedOrNeedsActivation, thisProtocolId);
                }
            break;

        case ProtocolLoadedAndMonitored:
            ASSERT(IsAddressChangeMonitoringOn(thisProtocolId));
            // if it was loaded, but is not active currently, we need to unload the protocol
            if (!fProtocolActive)
                {
#ifdef MAJOR_PNP_DEBUG
                DbgPrint("Protocol %d was just unloaded\n", thisProtocolId);
#endif
                CancelAddressChangeRequestIfNecessary(TRUE, thisProtocolId);
                UnloadProtocol(thisProtocolId);
                if (thisProtocolId == TCP)
                    {
                    GetTransportProtocol(HTTP)->UnloadProtocol(HTTP);
                    }
                SetState(ProtocolWasLoadedOrNeedsActivation, thisProtocolId);

                (*AddressChangeFn)((PVOID) State);
                }
            else
                {
#ifdef MAJOR_PNP_DEBUG
                DbgPrint("Protocol %d is monitored and received event\n", thisProtocolId);
#endif
                (*AddressChangeFn)((PVOID) State);
                }
            break;

#if defined(DBG) || defined(_DEBUG)
        default:
            ASSERT(!"Invalid State");
#endif
        }

    ASSERT_TRANSPORT_PROTOCOL_STATE(thisProtocolId);
}

void TransportProtocol::AddObjectToList(IN OUT BASE_ASYNC_OBJECT *pObj)
/*++
Function Name: AddObjectToList

Parameters:
    pObj - the object to be added

Description:
    Add the object to the list of transport objects for this protocol.

Returns:

--*/
{
    EnterCriticalSection(&AddressListLock);
    RpcpfInsertHeadList(&ObjectList, &pObj->ObjectList);
    LeaveCriticalSection(&AddressListLock);
}

void TransportProtocol::RemoveObjectFromList(IN OUT BASE_ASYNC_OBJECT *pObj)
/*++
Function Name: RemoveObjectFromList

Parameters:
    pObj - the object to be removed

Description:
    Removes the object from the list of transport objects for this protocol.

Returns:

--*/
{
    BASE_ASYNC_OBJECT *Prev, *Cur;

    Prev = NULL;

    EnterCriticalSection(&AddressListLock);

    RpcpfRemoveEntryList(&pObj->ObjectList);

    LeaveCriticalSection(&AddressListLock);
}

BOOL TransportProtocol::ResubmitQueriesIfNecessary(PROTOCOL_ID ProtocolId)
/*++
Function Name: ResubmitQueriesIfNecessary

Parameters:
    ProtocolId - the ID of the current protocol

Description:
    If there was a WSAIoctl pending that failed, it will be resubmitted.
    If this protocol was being monitored, try to restart monitoring if necessary

Returns:
    FALSE if the WSAIoctl was not resubmitted successfully.
    TRUE if the WSAIoctl was resubmitted successfully, or there was no need to resubmit it.

--*/
{
    if (addressChangeSocket)
        {
        if ((addressChangeOverlapped.Internal != 0) && (addressChangeOverlapped.Internal != STATUS_PENDING))
            {
            if (SubmitAddressChangeQuery() == FALSE)
                return FALSE;
            }
        }

    if (State == ProtocolLoadedAndMonitored)
        {
        if (MonitorFunctionalProtocolForAddressChange(ProtocolId) == FALSE)
            return FALSE;
        }

    return TRUE;
}

PROTOCOL_ID 
MapProtocolId (
    IN UINT ProtocolId,
    IN UINT AddressFamily
    )
/*++
Function Name: MapProtocolId

Parameters:
    ProtocolId - Winsock protocol ID
    AddressFamily - Winsock address family

Description:
    Converts a Winsock Protocol ID to a RPC Transport protocol ID.

Returns:
    The RPC Transport Protocol ID if successfull, or -1 if no mapping can be found

--*/
{
    unsigned id;

    for (id = 1; id < cWsTransportTable; id++)
        {
        if ((WsTransportTable[id].Protocol == (int) ProtocolId)
            && (WsTransportTable[id].AddressFamily == (int) AddressFamily))
            {
            return id;
            }
        }

    return -1;
}

BOOL TransportProtocol::HandlePnPStateChange(void)
/*++
Function Name: HandlePnPNotification

Parameters:

Description:
    Whenever a PnP notification (NewAddress) arrives, the completion port will direct it
    to this routine, which will handle all state management and all handling of the PnP
    notification.

Returns:
    TRUE if the runtime should be notified that a protocol state change has occurred.
    FALSE if the run time should not be notified, or need not be notified that a
        protocol state change has occurred.

--*/
{
    int i;

    //
    // Enumerate the currently loaded protocols
    //
    WSAPROTOCOL_INFO *lpProtocolBuffer;
    DWORD dwBufferLength = 512;
    int ProtocolCount;
    PROTOCOL_ID ProtocolId;
    TransportProtocol *pCurrentProtocol;
    BOOL fRetVal;

    EnterCriticalSection(&AddressListLock);

    ASSERT(hWinsock2);

    while (1)
        {
        lpProtocolBuffer = (WSAPROTOCOL_INFO *) I_RpcAllocate(dwBufferLength);
        if (lpProtocolBuffer == 0)
            {
            fRetVal = FALSE;
            goto CleanupAndReturn;
            }

        ProtocolCount = WSAEnumProtocolsT(
                              0,
                              lpProtocolBuffer,
                              &dwBufferLength
                              );
        if (ProtocolCount != SOCKET_ERROR)
            {
            break;
            }

        I_RpcFree(lpProtocolBuffer);

        if (GetLastError() != WSAENOBUFS)
            {
            fRetVal = FALSE;
            goto CleanupAndReturn;
            }
        }

    for (i = 1; i < MAX_PROTOCOLS; i++)
        {
        pCurrentProtocol = GetTransportProtocol(i);
        pCurrentProtocol->HandleProtocolChange(lpProtocolBuffer, ProtocolCount, i);
        }

    I_RpcFree(lpProtocolBuffer);

    fRetVal = g_NotifyRt;

CleanupAndReturn:
    LeaveCriticalSection(&AddressListLock);
#ifdef MAJOR_PNP_DEBUG
    DumpProtocolState();
#endif
    return fRetVal;
}

BOOL TransportProtocol::ResubmitQueriesIfNecessary(void)
/*++
Function Name: ResubmitQueriesIfNecessary

Parameters:

Description:
    Iterates through all protocols and calls their ResubmitQueriesIfNecessary

Returns:
    FALSE if at least one protocol needed to resubmit a query, but failed to do so
    TRUE otherwise

--*/
{
    int i;
    BOOL fAllResubmitsSucceeded = TRUE;
    TransportProtocol *pCurrentProtocol;

#ifdef MAJOR_PNP_DEBUG
    DbgPrint("Resubmitting queries for process %d\n", GetCurrentProcessId());
#endif

    EnterCriticalSection(&AddressListLock);

    for (i = 1; i < MAX_PROTOCOLS; i++)
        {
        pCurrentProtocol = GetTransportProtocol(i);
        if (!pCurrentProtocol->ResubmitQueriesIfNecessary(i))
            fAllResubmitsSucceeded = FALSE;
        }

    LeaveCriticalSection(&AddressListLock);

    return fAllResubmitsSucceeded;
}

void TransportProtocol::AddObjectToProtocolList(BASE_ASYNC_OBJECT *pObj)
{
    GetTransportProtocol(pObj->id)->AddObjectToList(pObj);
}

void TransportProtocol::RemoveObjectFromProtocolList(IN OUT BASE_ASYNC_OBJECT *pObj)
{
    // in some cases, we can legally have the id set to INVALID_PROTOCOL_ID
    // this happens when we have initialized the connection, but have failed
    // before calling Open on it, and then we attempt to destroy it
    if (pObj->id != INVALID_PROTOCOL_ID)
        {
        GetTransportProtocol(pObj->id)->RemoveObjectFromList(pObj);
        }
}

BOOL TransportProtocol::VerifyProtocolIsFunctional(IN PROTOCOL_ID ProtocolId)
/*++
    Function Name: VerifyProtocolIsFunctional

    Parameters: ProtocolId - the protocol which we're attempting to verify as functional or not

    Description: Tries to find out the listening address for a loaded protocol. The address
        itself is not used anywhere. It just testifies that the protocol is fully operational.
        Depending on how far it gets with testing whether the protocol is operational,
        it will change the State to ProtocolLoaded, ProtocolLoadedWithoutAddress or
        ProtocolWasLoadedOrNeedsActivationWithoutAddress. It will return TRUE iff the state is moved to
        ProtocolLoaded.

    Returns: TRUE if the address was found and the protocol was fully operational
             FALSE if the address could not be found, and the protocol is not
                fully operational. Note that there are two subcases here. One is when
                the protocol is not operational (or we cannot confirm that for lack of
                resources for example) and it has no sign of becoming operational. The
                second is when the protocol is not operational, but there are chances of
                it becoming operational. This happens with protocols that take some
                time to initialize. In the second case, this function will arrange for
                a retry attempt by posting an async WSAIoctl request to the completion
                port. In the current code base, we don't differentiate between the two
                cases because we don't need to. We may need to do so in the future.

--*/
{
    ASSERT((State == ProtocolNotLoaded) 
        || (State == ProtocolWasLoadedOrNeedsActivation) 
        || (State == ProtocolLoadedWithoutAddress) 
        || (State == ProtocolWasLoadedOrNeedsActivationWithoutAddress));

    ASSERT_TRANSPORT_PROTOCOL_STATE(ProtocolId);

    if (OpenAddressChangeRequestSocket(ProtocolId) == FALSE)
        goto AbortAndCleanup;

    // if the socket already has an address, skip further checks
    // NOTE: this check provides a fast way to check initialization state of
    // protocols that initialize quickly, but more importantly, it provides a
    // handling path for protocols that have submitted an address list change query
    // and now are getting back the result
    if (DoesAddressSocketHaveAddress())
        {

#ifdef MAJOR_PNP_DEBUG
        DbgPrint("Protocol %d is functional (1)\n", ProtocolId);
#endif

        CancelAddressChangeRequestIfNecessary(FALSE, ProtocolId);
        SetStateToLoadedAndMonitorProtocolIfNecessary(ProtocolId);
        ASSERT_TRANSPORT_PROTOCOL_STATE(ProtocolId);
        return TRUE;
        }

    // if there isn't a pending request, and there isn't a successful request (i.e. there is either
    // a failed request, or no request has been submitted so far)
    if ((addressChangeOverlapped.Internal != 0) && (addressChangeOverlapped.Internal != STATUS_PENDING))
        {
#ifdef MAJOR_PNP_DEBUG
        DbgPrint("Submitting WSAIoclt for protocol %d\n", ProtocolId);
#endif

        if (!SubmitAddressChangeQuery())
            goto AbortAndCleanup;
        }

    // check once more whether we have address - this takes care of the race where the
    // address did arrive between the time we checked for it in the beginning of this
    // function and the time we submitted the address change query
    if (DoesAddressSocketHaveAddress())
        {
#ifdef MAJOR_PNP_DEBUG
        DbgPrint("Protocol %d is functional (2)\n", ProtocolId);
#endif
        CancelAddressChangeRequestIfNecessary(FALSE, ProtocolId);
        SetStateToLoadedAndMonitorProtocolIfNecessary(ProtocolId);
        ASSERT_TRANSPORT_PROTOCOL_STATE(ProtocolId);
        return TRUE;
        }

    // regardless of whether we succeeded immediately or we are pending, advance the
    // state to ProtocolLoadedWithoutAddress and return not loaded. The completion at the
    // completion port will take care of the rest
    if (State == ProtocolWasLoadedOrNeedsActivation)
        SetState(ProtocolWasLoadedOrNeedsActivationWithoutAddress, ProtocolId);
    else if (State == ProtocolNotLoaded)
        SetState(ProtocolLoadedWithoutAddress, ProtocolId);
#ifdef MAJOR_PNP_DEBUG
    else
        {
        DbgPrint("VerifyProtocolIsFunctional did not change state for protocol %d, state: %s\n", ProtocolId,
            ProtocolStateNames[State]);
        }
#endif

    ASSERT_TRANSPORT_PROTOCOL_STATE(ProtocolId);
    return FALSE;

AbortAndCleanup:
    // TRUE or FALSE for this argument doesn't matter here -
    // the operation has failed
    CancelAddressChangeRequestIfNecessary(FALSE, ProtocolId);
    ASSERT_TRANSPORT_PROTOCOL_STATE(ProtocolId);
    return FALSE;
}

BOOL TransportProtocol::DoesAddressSocketHaveAddress(void)
/*++
Function Name: DoesAddressSocketHaveAddress

Parameters:

Description:
    Checks if a valid address can be obtained for this protocol.

Returns:
    TRUE - a valid address could be obtained for this protocol
    FALSE - otherwise

--*/
{
    DWORD byteRet = 0;
    char buf[40];

    ASSERT(addressChangeSocket != 0);

    if (WSAIoctl(addressChangeSocket, SIO_ADDRESS_LIST_QUERY,
                 0, 0, buf, sizeof(buf), &byteRet, NULL, NULL) == SOCKET_ERROR)
        {
        return FALSE;
        }

    // if the result has non-zero length ...
    if (byteRet != 0)
        {
#if 0
        int i;
        DbgPrint("WSAIoctl returned:\n");
        for (i = 0; i < byteRet; i ++)
            {
            DbgPrint(" %X", (unsigned long) buf[i]);
            }
        DbgPrint("\nWSAIoctl with ADDRESS_LIST_QUERY returned addresses success\n");
#endif

        // ... and the resulting value is non zero ...
        if (*(long *)buf != 0)
            {
            // ... we have managed to get the true address
            return TRUE;
            }
        }

    return FALSE;
}

void TransportProtocol::CancelAddressChangeRequestIfNecessary(BOOL fForceCancel, IN PROTOCOL_ID ProtocolId)
/*++
Function Name: CancelAddressChangeRequestIfNecessary

Parameters:

Description:
    If there's an active WSAIoctl on the protocol, cancel it by closing the socket.

Returns:

--*/
{
    if (addressChangeSocket != 0)
        {
        // if the address change monitoring is off, or cancel is
        // forced, do the actual cancelling. That is, we don't
        // cancel if this is a monitored protocol and cancel is
        // optional
        if (!IsAddressChangeMonitoringOn(ProtocolId) || fForceCancel)
            {
#ifdef MAJOR_PNP_DEBUG
            DbgPrint("Address change request cancelled\n");
#endif
            closesocket(addressChangeSocket);
            addressChangeSocket = 0;
            addressChangeOverlapped.Internal = -1;
            }
        }
}

void TransportProtocol::RestartProtocol(PROTOCOL_ID ProtocolId)
/*++
Function Name: RestartProtocol

Parameters:
    ProtocolId - the protocol to be restarted.

Description:
    Restarts all addresses on this protocol.

Returns:

--*/
{
    BASE_ASYNC_OBJECT *Obj;
    BOOL fAddressFound = 0;
    RPC_STATUS Status;
    LIST_ENTRY *CurrentEntry;

    VALIDATE(ProtocolId)
        {
        TCP,
#ifdef SPX_ON
        SPX,
#endif
#ifdef APPLETALK_ON
        DSP,
#endif
        HTTP,
        UDP,
#ifdef IPX_ON
        IPX,
#endif
        TCP_IPv6
        } END_VALIDATE;

    CurrentEntry = ObjectList.Flink;

    while(CurrentEntry != &ObjectList)
        {
        Obj = CONTAINING_RECORD(CurrentEntry, BASE_ASYNC_OBJECT, ObjectList);
        ASSERT(Obj->id == (int) ProtocolId);

        if (Obj->type & ADDRESS)
            {
            if (Obj->type & DATAGRAM)
                {
                Status = DG_ReactivateAddress((WS_DATAGRAM_ENDPOINT *) Obj);
                }
            else
                {
                Status = WS_ReactivateAddress((WS_ADDRESS *) Obj);
                }

            if (Status == RPC_S_OK)
                {
                fAddressFound = 1;
                COMMON_AddressManager((BASE_ADDRESS *) Obj);
                }
            }
        CurrentEntry = CurrentEntry->Flink;
        }

    if (fAddressFound)
        {
        COMMON_PostNonIoEvent(TRANSPORT, 0, 0);
        }
}

void TransportProtocol::UnloadProtocol(PROTOCOL_ID ProtocolId)
/*++
Function Name: UnloadProtocol

Parameters:
    ProtocolId - the protocol to be unloaded.

Description:
    Walks the list of the protocol transport objects. Closes the connections, and removes the
        addresses from the list. Thus failing requests on addresses will not be retried.

Returns:

--*/
{
    BASE_ASYNC_OBJECT *Obj;
    LIST_ENTRY *CurrentEntry;

    VALIDATE(ProtocolId)
        {
        TCP,
#ifdef SPX_ON
        SPX,
#endif
#ifdef APPLETALK_ON
        DSP,
#endif
        HTTP,
        UDP,
#ifdef IPX_ON
        IPX,
#endif
        TCP_IPv6,
        HTTPv2
        } END_VALIDATE;

    CurrentEntry = ObjectList.Flink;

    //
    // - Cleanup all the objects (ie: close the socket).
    // - Remove all objects other than address objects
    //   from the list.
    //
    while(CurrentEntry != &ObjectList)
        {
        Obj = CONTAINING_RECORD(CurrentEntry, BASE_ASYNC_OBJECT, ObjectList);

        ASSERT(Obj->id == (int)ProtocolId);

        if (Obj->type & ADDRESS)
            {
            COMMON_RemoveAddress((BASE_ADDRESS *) Obj);
            }
        else
            {
            RpcpfRemoveEntryList(&Obj->ObjectList);
            
            if (ProtocolId != HTTPv2)
                WS_Abort(Obj);
            else
                HTTP_Abort(Obj);
            }

        CurrentEntry = CurrentEntry->Flink;
        }
}

BOOL TransportProtocol::SubmitAddressChangeQuery(void)
/*++
Function Name: SubmitAddressChangeQuery

Parameters:

Description:
    Submits an address change query (WSAIoctl)

Returns:
    TRUE if the WSAIoctl was successfully posted.
    FALSE otherwise

--*/
{
    ASSERT(addressChangeSocket != 0);
    static DWORD dwBytesReturned;

    //
    // Post an address list change request
    //
    addressChangeOverlapped.hEvent = 0;
    addressChangeOverlapped.Offset = 0;
    addressChangeOverlapped.OffsetHigh = 0;
    addressChangeOverlapped.Internal = 0;

    // submit the address change request - it will always complete on the completion port
    // we don't care about the dwBytesReturned. The provider requires a valid address, or
    // it rejects the request
    if (WSAIoctl(addressChangeSocket, SIO_ADDRESS_LIST_CHANGE,
                 0, 0, 0, 0, &dwBytesReturned, &addressChangeOverlapped, 0) == SOCKET_ERROR)
        {
        if (WSAGetLastError() != ERROR_IO_PENDING)
            {
#ifdef MAJOR_PNP_DEBUG
            DbgPrint("Submitting WSAIoclt failed with: %d\n", GetLastError());
#endif
            return FALSE;
            }
        }

    return TRUE;
}

void TransportProtocol::SetState(TransportProtocolStates newState, PROTOCOL_ID ProtocolId)
/*++
Function Name: SetState

Parameters:
    newState - the new state that the protocol needs to move to
    ProtocolId - the protocol number of this protocol

Description:
    Sets the state of the protocol. Nobody should write the state directly, because
        protocol state mirroring will stop working.

Returns:

--*/
{
    TransportProtocol *CurrentProtocol;

#ifdef MAJOR_PNP_DEBUG
    DbgPrint("Protocol %d moved from state: %s to state: %s\n", ProtocolId, ProtocolStateNames[State],
        ProtocolStateNames[newState]);
#endif

    // either the address change monitoring is not on for this protocol, or
    // the protocol doesn't move to loaded state, but not both
    ASSERT(!IsAddressChangeMonitoringOn(ProtocolId) || (newState != ProtocolLoaded));
    State = newState;
    if (ProtocolId == TCP)
        {
        // if a base protocols is moved into loaded and monitored, make sure
        // the trailing protocols doesn't follow it there. In such a case
        // the trailing protocol becomes only loaded
        if (newState == ProtocolLoadedAndMonitored)
            {
            GetTransportProtocol(HTTP)->State = ProtocolLoaded;
            }
        else
            {
            GetTransportProtocol(HTTP)->State = newState;
            }

        MirrorProtocolState(TCP_IPv6);
        }
    else if (ProtocolId == TCP_IPv6)
        {
        MirrorProtocolState(TCP);
        }
}

void TransportProtocol::SetStateToLoadedAndMonitorProtocolIfNecessary(PROTOCOL_ID ProtocolId)
{
    if (IsAddressChangeMonitoringOn(ProtocolId))
        {
        // monitor functional protocols for address change will
        // set the state
        MonitorFunctionalProtocolForAddressChange(ProtocolId);
        }
    else
        SetState(ProtocolLoaded, ProtocolId);
}

RPC_STATUS InitTransportProtocols(void)
/*++
Function Name: InitTransportProtocols

Parameters:

Description:
    Initializes all transport level protocols. This function should be called before
    any of the TransportProtocol functions.

Returns:

--*/
{
    TransportProtocolArray = new TransportProtocol[MAX_PROTOCOLS];
    if (TransportProtocolArray == NULL)
        return (RPC_S_OUT_OF_MEMORY);
    else
        return RPC_S_OK;
}

#if defined(DBG) || defined(_DEBUG)
void TransportProtocol::AssertTransportProtocolState(void)
/*++
Function Name: AssertTransportProtocolState

Parameters:

Description:
    Loops through all protocols and calls AssertState on them

Returns:

--*/
{
    int i;

    for (i = 1; i < MAX_PROTOCOLS; i ++)
        {
        GetTransportProtocol(i)->AssertState(i);
        }
}

void TransportProtocol::AssertState(PROTOCOL_ID ProtocolId)
/*++
Function Name: AssertState

Parameters:
    ProtocolId - the protocol number of the this protocol

Description:
    Currently this includes that addressChangeSocket is set only in the *WithoutAddress states
        and that all the objects in this protocol list are of the same protocol as this protocol.

Returns:

--*/
{
    BASE_ASYNC_OBJECT *pObject;
    LIST_ENTRY *CurrentEntry;

    // make sure that the internal state of the object is consistent
    ASSERT (State >= ProtocolNotLoaded);
    ASSERT (State <= ProtocolLoadedAndMonitored);

    if (IsTrailingProtocol(ProtocolId))
        {
        ASSERT(addressChangeSocket == 0);
        }
    else
        {
        // if we are in one of these states, there should be no address change request pending
        if ((State == ProtocolNotLoaded) 
            || (State == ProtocolWasLoadedOrNeedsActivation) 
            || (State == ProtocolLoaded))
            {
            ASSERT(addressChangeSocket == 0);
            }
        else
            {
            // if we are in one of the else states, there must be address change request pending
            ASSERT(addressChangeSocket != 0);
            }
        }

    // walk the object list and make sure every object is of the same protocol
    CurrentEntry = ObjectList.Flink;

    while (CurrentEntry != &ObjectList)
        {
        pObject = CONTAINING_RECORD(CurrentEntry, BASE_ASYNC_OBJECT, ObjectList);
        ASSERT(pObject->id == ProtocolId);
        CurrentEntry = CurrentEntry->Flink;
        }
}

#endif

BOOL TransportProtocol::MonitorFunctionalProtocolForAddressChange(PROTOCOL_ID ProtocolId)
/*++
Function Name: MonitorFunctionalProtocolForAddressChange

Parameters:
    ProtocolId - the protocol id of the current protocol

Description:
    Makes sure that an already functional protocol is monitored for address change. This is done
    by:
    - if an address change socket does not exist, one is opened.
    - if no address change WSAIoctl is pending on the socket, one is posted.

Returns:
    TRUE if the posting of address change was successful
    FALSE if it wasn't

--*/
{
    BOOL bRetVal = FALSE;

    // OpenAddressChangeRequestSocket will take care to check whether there's already
    // a socket opened
    if (OpenAddressChangeRequestSocket(ProtocolId) == FALSE)
        goto Cleanup;

    if (addressChangeOverlapped.Internal != STATUS_PENDING)
        {
        if (SubmitAddressChangeQuery() == FALSE)
            goto Cleanup;
        }

    bRetVal = TRUE;
Cleanup:
    if (State != ProtocolLoadedAndMonitored)
        SetState(ProtocolLoadedAndMonitored, ProtocolId);

    return bRetVal;
}

BOOL TransportProtocol::OpenAddressChangeRequestSocket(PROTOCOL_ID ProtocolId)
/*++
Function Name: OpenAddressChangeRequestSocket

Parameters:
    ProtocolId - the protocol id of the current protocol

Description:
    Makes sure that an address change request socket is opened.

Returns:
    TRUE if the opening was successful
    FALSE if it wasn't

--*/
{
    const WS_TRANS_INFO *pInfo = &WsTransportTable[ProtocolId];
    HANDLE h;

    // we may end up with non-zero addressChangeSocket if this is an address change query
    // request coming back to us. In this case we don't need to open up another socket
    if (addressChangeSocket == 0)
        {
        ASSERT((State == ProtocolNotLoaded) 
            || (State == ProtocolWasLoadedOrNeedsActivation) 
            || (State == ProtocolLoaded));

        //
        // Create a socket
        //
        addressChangeSocket = WSASocketT(pInfo->AddressFamily,
                          pInfo->SocketType,
                          pInfo->Protocol,
                          0,
                          0,
                          WSA_FLAG_OVERLAPPED);
        if (addressChangeSocket == INVALID_SOCKET)
            {
            //
            // We should be able to at least open a socket on the protocol,
            // if not we got a bogus notification or we're out of resources
            addressChangeSocket = 0;
            return FALSE;
            }

        //
        // make the handle non-inheritable so it goes away when we close it.
        //
        if (FALSE == SetHandleInformation( (HANDLE) addressChangeSocket, HANDLE_FLAG_INHERIT, 0))
            {
            closesocket(addressChangeSocket);
            addressChangeSocket = 0;
            return FALSE;
            }

        // associate the socket with the completion port so that we get the notification there
        h = CreateIoCompletionPort((HANDLE)addressChangeSocket,
                               RpcCompletionPort,
                               NewAddress,
                               0);
        if (h == 0)
            {
            closesocket(addressChangeSocket);
            addressChangeSocket = 0;
            return FALSE;
            }
        else
            {
            ASSERT(h == RpcCompletionPort);
            }
        }
    else
        {
        // we may have a protocol in state ProtocolNotLoaded, because we are just trying
        // to bring it to loaded state
        ASSERT((State == ProtocolLoadedWithoutAddress) 
            || (State == ProtocolWasLoadedOrNeedsActivationWithoutAddress) 
            || (State == ProtocolLoadedAndMonitored) || (State == ProtocolNotLoaded));
        }

#ifdef MAJOR_PNP_DEBUG
    DbgPrint("Socket was successfully opened for protocol %d\n", ProtocolId);
#endif

    return TRUE;
}

void 
TransportProtocol::MirrorProtocolState (
    IN PROTOCOL_ID MirrorProtocolId
    )
/*++
Function Name: MirrorProtocolState

Parameters:
    MirrorProtocolId - the protocol which is mirrored

Description:
    If this is one of the protocols in a dual stack configuration, change
    the other protocol into appropriate state

Returns:

--*/
{
    TransportProtocol *MirrorProtocol;

    MirrorProtocol = GetTransportProtocol(MirrorProtocolId);
    if ((State == ProtocolLoadedAndMonitored) || (State == ProtocolLoaded))
        {
        if (MirrorProtocol->State == ProtocolNotLoaded)
            {
            MirrorProtocol->SetState(ProtocolWasLoadedOrNeedsActivation, MirrorProtocolId);
            }
        else if (MirrorProtocol->State == ProtocolLoadedWithoutAddress)
            {
            MirrorProtocol->SetState(ProtocolWasLoadedOrNeedsActivationWithoutAddress, MirrorProtocolId);
            }
        }
}

#ifdef MAJOR_PNP_DEBUG
void TransportProtocol::DumpProtocolState(void)
/*++
Function Name: DumpProtocolState

Parameters:

Description:
    Iterates through all protocol and calls their DumpProtocolState

Returns:

--*/
{
    int i;

    DbgPrint("Dumping protocol state for process %d\n", GetCurrentProcessId());

    for (i = 1; i < MAX_PROTOCOLS; i ++)
        {
        GetTransportProtocol(i)->DumpProtocolState(i);
        }
}

const char *ProtocolStateNames[] = {"ProtocolNotLoaded", "ProtocolLoadedWithoutAddress" ,
                                    "ProtocolWasLoadedOrNeedsActivation", "ProtocolLoaded", 
                                    "ProtocolWasLoadedOrNeedsActivationWithoutAddress",
                                    "ProtocolLoadedAndMonitored"};


void TransportProtocol::DumpProtocolState(PROTOCOL_ID ProtocolId)
/*++
Function Name: DumpProtocolState

Parameters:
    ProtocolId - the protocol number for this protocol.

Description:
    Dumps all significant information for this protcool on the debugger

Returns:

--*/
{
    BASE_ASYNC_OBJECT *pCurrentObject;
    LIST_ENTRY *pCurrentEntry = ObjectList.Flink;
    int fFirstTime = TRUE;
    const RPC_CHAR *Protseq;

    if (TransportTable[ProtocolId].pInfo)
        Protseq = TransportTable[ProtocolId].pInfo->ProtocolSequence;
    else
        Protseq = L"(null)";

    DbgPrint("Protocol: %S\n", Protseq);
    DbgPrint("State: %s, Addr Change Socket: %X, Addr Change Overlapped: %X\n",
        ProtocolStateNames[State], addressChangeSocket, (ULONG_PTR)&addressChangeOverlapped);
    while (pCurrentEntry != &ObjectList)
        {
        if (fFirstTime)
            {
            DbgPrint("Object List:\n");
            fFirstTime = FALSE;
            }
        pCurrentObject = CONTAINING_RECORD(pCurrentEntry, BASE_ASYNC_OBJECT, ObjectList);
        DbgPrint("\t%X\n", (ULONG_PTR)pCurrentObject);
        pCurrentEntry = pCurrentEntry->Flink;
        }
}
#endif

TransportProtocol *TransportProtocolArray;