messagemgr.c

WinCE5.0部分核心源码

    dwError = WSASendTo(
                pDhcpV6Adapt->Socket,
                &WSABuf,
                1,
                &uByteSent,
                0,
                (LPSOCKADDR)&MCastSockAddr,
                sizeof(MCastSockAddr),
                NULL,
                NULL
                );
    BAIL_ON_LOCK_ERROR(dwError);

UpdateTime:
    if (pDhcpV6Adapt->pPdOption)
        ReXmitTime = FindMaxTimeout(pDhcpV6Adapt, 
            pDhcpV6Adapt->pPdOption->T2 * SEC_TO_MS,
            pDhcpV6Adapt->uRetransmissionTimeout);
    else
        ReXmitTime = pDhcpV6Adapt->uRetransmissionTimeout;

    dwError = DhcpV6TimerSetTimer(
                gpDhcpV6TimerModule,
                pDhcpV6Adapt,
                DHCPV6MessageMgrTimerCallbackRoutine,
                pDhcpV6Adapt,
                ReXmitTime
                );
    BAIL_ON_LOCK_ERROR(dwError);

    CalculateRexmitTimeout(pDhcpV6Adapt);

    ReleaseExclusiveLock(&pDhcpV6Adapt->RWLock);

success:

    if (pDhcpV6MessageHeader) {
        FreeDHCPV6Mem(pDhcpV6MessageHeader);
    }

    DhcpV6Trace(DHCPV6_SEND, DHCPV6_LOG_LEVEL_TRACE, ("End Information Request"));

    return dwError;

lock:

    DhcpV6Trace(DHCPV6_SEND, DHCPV6_LOG_LEVEL_ERROR, ("FAILED Information Request with Error: %!status!", dwError));

    ReleaseExclusiveLock(&pDhcpV6Adapt->RWLock);
    DereferenceDHCPV6Adapt(pDhcpV6Adapt);

    goto success;
}


//
//  Lock: None
//
DWORD
DHCPV6MessageMgrRebindMessage(
    PDHCPV6_ADAPT pDhcpV6Adapt
    )
{
    DWORD dwError = 0;
    ULONG uInfoRequestLength = 0;
    PDHCPV6_OPTION_MODULE pDhcpV6OptionModule = &pDhcpV6Adapt->DhcpV6OptionModule;
    PDHCPV6_MESSAGE_HEADER pDhcpV6MessageHeader = NULL;
    PUCHAR pucOptionHeader = NULL;
    USHORT usOptionLength = 0;
    WSABUF WSABuf = { 0 };
    ULONG uByteSent = 0;
    ULONG   ReXmitTime;


    DhcpV6Trace(DHCPV6_SEND, DHCPV6_LOG_LEVEL_TRACE, ("Begin Information Request on Adapt: %d", pDhcpV6Adapt->dwIPv6IfIndex));

    AcquireExclusiveLock(&pDhcpV6Adapt->RWLock);
    if (pDhcpV6Adapt->DhcpV6State == dhcpv6_state_deinit) {
        ReleaseExclusiveLock(&pDhcpV6Adapt->RWLock);
        DereferenceDHCPV6Adapt(pDhcpV6Adapt);
        return 0;
    }

    if (DHCPV6_MEDIA_DISC_FL & pDhcpV6Adapt->Flags) {
        goto UpdateTime;
    }

    // options: ClientID, ORO (Option-Request-Option), IA_PD, elapsed time
   
    // ORO options: DNS_SERVERS, IA_PD
    usOptionLength = (USHORT)(2 * sizeof(USHORT));
    //usOptionLength = (USHORT)(pDhcpV6OptionModule->uNumOfOptionsEnabled * sizeof(USHORT));
    
    uInfoRequestLength = sizeof(DHCPV6_MESSAGE_HEADER) +    // Fixed size header
        (sizeof(DHCPV6_OPTION_HEADER) * 4) + // ClientID, ORO, IA_PD, elapsed t
        (4 + pDhcpV6Adapt->cPhysicalAddr) + // DUID (ClientID) length
        usOptionLength + IA_PD_OPTION_LEN + 2;  // ORO + IA_PD + elapsed time

    uInfoRequestLength += sizeof(DHCPV6_OPTION_HEADER) + IA_PREFIX_OPTION_LEN;

    pDhcpV6MessageHeader = AllocDHCPV6Mem(uInfoRequestLength);
    if (!pDhcpV6MessageHeader) {
        dwError = ERROR_OUTOFMEMORY;
        BAIL_ON_LOCK_ERROR(dwError);
    }
    memset(pDhcpV6MessageHeader, 0, uInfoRequestLength);

    pDhcpV6MessageHeader->MessageType = DHCPV6_MESSAGE_TYPE_REBIND;

    dwError = DhcpV6GenerateRandom(pDhcpV6Adapt->ucTransactionID, sizeof(pDhcpV6Adapt->ucTransactionID));
    BAIL_ON_LOCK_ERROR(dwError);

    memcpy(
        pDhcpV6MessageHeader->TransactionID,
        pDhcpV6Adapt->ucTransactionID,
        sizeof(pDhcpV6MessageHeader->TransactionID)
        );

    pucOptionHeader = (PUCHAR)(&pDhcpV6MessageHeader[1]);

    if (dhcpv6_state_rebindconfirm != pDhcpV6Adapt->DhcpV6State)
        pDhcpV6Adapt->DhcpV6State = dhcpv6_state_T2;

    dwError = DhcpV6OptionMgrCreateOptionRequestPD(
                    pDhcpV6Adapt,
                    pDhcpV6OptionModule,
                    pucOptionHeader,
                    sizeof(DHCPV6_OPTION_HEADER) + usOptionLength
                    );
    BAIL_ON_LOCK_ERROR(dwError);

    DEBUGMSG(1, (TEXT("DhcpV6: Sending Rebind message\r\n")));

    WSABuf.len = uInfoRequestLength;
    WSABuf.buf = (PUCHAR)pDhcpV6MessageHeader;
    dwError = WSASendTo(
                pDhcpV6Adapt->Socket,
                &WSABuf,
                1,
                &uByteSent,
                0,
                (LPSOCKADDR)&MCastSockAddr,
                sizeof(MCastSockAddr),
                NULL,
                NULL
                );
    BAIL_ON_LOCK_ERROR(dwError);

UpdateTime:
    if (pDhcpV6Adapt->pPdOption)
        ReXmitTime = FindMaxTimeout(pDhcpV6Adapt, 
            pDhcpV6Adapt->pPdOption->IAPrefix.ValidLifetime * SEC_TO_MS,
            pDhcpV6Adapt->uRetransmissionTimeout);
    else
        ReXmitTime = pDhcpV6Adapt->uRetransmissionTimeout;

    if ((dhcpv6_state_rebindconfirm == pDhcpV6Adapt->DhcpV6State) &&
        (ReXmitTime > pDhcpV6Adapt->uRetransmissionTimeout)) {
        ReXmitTime = pDhcpV6Adapt->uRetransmissionTimeout;
    }

    dwError = DhcpV6TimerSetTimer(
                gpDhcpV6TimerModule,
                pDhcpV6Adapt,
                DHCPV6MessageMgrTimerCallbackRoutine,
                pDhcpV6Adapt,
                ReXmitTime
                );
    BAIL_ON_LOCK_ERROR(dwError);

    CalculateRexmitTimeout(pDhcpV6Adapt);

    ReleaseExclusiveLock(&pDhcpV6Adapt->RWLock);

success:

    if (pDhcpV6MessageHeader) {
        FreeDHCPV6Mem(pDhcpV6MessageHeader);
    }

    DhcpV6Trace(DHCPV6_SEND, DHCPV6_LOG_LEVEL_TRACE, ("End Information Request"));

    return dwError;

lock:

    DhcpV6Trace(DHCPV6_SEND, DHCPV6_LOG_LEVEL_ERROR, ("FAILED Information Request with Error: %!status!", dwError));

    ReleaseExclusiveLock(&pDhcpV6Adapt->RWLock);
    DereferenceDHCPV6Adapt(pDhcpV6Adapt);

    goto success;
}


#endif  // UNDER_CE

//
//  Lock: None
//
DWORD
DHCPV6MessageMgrInfoRequest(
    PDHCPV6_ADAPT pDhcpV6Adapt
    )
{
    DWORD dwError = 0;
    ULONG uInfoRequestLength = 0;
    PDHCPV6_OPTION_MODULE pDhcpV6OptionModule = &pDhcpV6Adapt->DhcpV6OptionModule;
    PDHCPV6_MESSAGE_HEADER pDhcpV6MessageHeader = NULL;
    PUCHAR pucOptionHeader = NULL;
    USHORT usOptionLength = 0;
    WSABUF WSABuf = { 0 };
    ULONG uByteSent = 0;


    DhcpV6Trace(DHCPV6_SEND, DHCPV6_LOG_LEVEL_TRACE, ("Begin Information Request on Adapt: %d", pDhcpV6Adapt->dwIPv6IfIndex));

    AcquireExclusiveLock(&pDhcpV6Adapt->RWLock);
    if (pDhcpV6Adapt->DhcpV6State == dhcpv6_state_deinit) {
        ReleaseExclusiveLock(&pDhcpV6Adapt->RWLock);
        DereferenceDHCPV6Adapt(pDhcpV6Adapt);
        return 0;
    }

    if (DHCPV6_MEDIA_DISC_FL & pDhcpV6Adapt->Flags) {
        goto UpdateTime;
    }

    // ORO options: DNS_SERVERS, IA_PD
    usOptionLength = (USHORT)(2 * sizeof(USHORT));
    //usOptionLength = (USHORT)(pDhcpV6OptionModule->uNumOfOptionsEnabled * sizeof(USHORT));

    uInfoRequestLength = sizeof(DHCPV6_MESSAGE_HEADER) +    // Fixed size header
                         sizeof(DHCPV6_OPTION_HEADER) +     // Option-Request-Option
                         usOptionLength;

    pDhcpV6MessageHeader = AllocDHCPV6Mem(uInfoRequestLength);
    if (!pDhcpV6MessageHeader) {
        dwError = ERROR_OUTOFMEMORY;
        BAIL_ON_LOCK_ERROR(dwError);
    }
    memset(pDhcpV6MessageHeader, 0, uInfoRequestLength);

    pDhcpV6MessageHeader->MessageType = DHCPV6_MESSAGE_TYPE_INFORMATION_REQUEST;

    dwError = DhcpV6GenerateRandom(pDhcpV6Adapt->ucTransactionID, sizeof(pDhcpV6Adapt->ucTransactionID));
    BAIL_ON_LOCK_ERROR(dwError);

    memcpy(
        pDhcpV6MessageHeader->TransactionID,
        pDhcpV6Adapt->ucTransactionID,
        sizeof(pDhcpV6MessageHeader->TransactionID)
        );

    pucOptionHeader = (PUCHAR)(&pDhcpV6MessageHeader[1]);
    dwError = DhcpV6OptionMgrCreateOptionRequest(
                    pDhcpV6OptionModule,
                    pucOptionHeader,
                    sizeof(DHCPV6_OPTION_HEADER) + usOptionLength
                    );
    BAIL_ON_LOCK_ERROR(dwError);

    pDhcpV6Adapt->DhcpV6State = dhcpv6_state_request;

    DEBUGMSG(1, (TEXT("DhcpV6: Sending Info Request message\r\n")));

    WSABuf.len = uInfoRequestLength;
    WSABuf.buf = (PUCHAR)pDhcpV6MessageHeader;
    dwError = WSASendTo(
                pDhcpV6Adapt->Socket,
                &WSABuf,
                1,
                &uByteSent,
                0,
                (LPSOCKADDR)&MCastSockAddr,
                sizeof(MCastSockAddr),
                NULL,
                NULL
                );
    BAIL_ON_LOCK_ERROR(dwError);

    dwError = DhcpV6TimerSetTimer(
                gpDhcpV6TimerModule,
                pDhcpV6Adapt,
                DHCPV6MessageMgrTimerCallbackRoutine,
                pDhcpV6Adapt,
                pDhcpV6Adapt->uRetransmissionTimeout
                );
    BAIL_ON_LOCK_ERROR(dwError);

UpdateTime:

    CalculateRexmitTimeout(pDhcpV6Adapt);

    ReleaseExclusiveLock(&pDhcpV6Adapt->RWLock);

success:

    if (pDhcpV6MessageHeader) {
        FreeDHCPV6Mem(pDhcpV6MessageHeader);
    }

    DhcpV6Trace(DHCPV6_SEND, DHCPV6_LOG_LEVEL_TRACE, ("End Information Request"));

    return dwError;

lock:

    DhcpV6Trace(DHCPV6_SEND, DHCPV6_LOG_LEVEL_ERROR, ("FAILED Information Request with Error: %!status!", dwError));

    ReleaseExclusiveLock(&pDhcpV6Adapt->RWLock);
    DereferenceDHCPV6Adapt(pDhcpV6Adapt);

    goto success;
}


DWORD
InitDHCPV6MessageMgr(
    PDHCPV6_ADAPT pDhcpV6Adapt          // Should be ref-counted already by caller
    )
{
    DWORD dwError = 0;

    if (gbDHCPV6PDEnabled && (DHCPV6_PD_ENABLED_FL & pDhcpV6Adapt->Flags))
        dwError = DHCPV6MessageMgrSolicitMessage(pDhcpV6Adapt);
    else
        dwError = DHCPV6MessageMgrInfoRequest(pDhcpV6Adapt);
    BAIL_ON_WIN32_ERROR(dwError);

error:
    return dwError;
}


DWORD
DHCPV6MessageMgrPerformRefresh(
    PDHCPV6_ADAPT pDhcpV6Adapt
    )
{
    DWORD   dwError = 0;
    BOOL    bAdaptReference = FALSE;
    BOOL    bUsePD;
    CHAR    szAdapterName[DHCPV6_MAX_NAME_SIZE];


    DhcpV6Trace(DHCPV6_IOCTL, DHCPV6_LOG_LEVEL_TRACE, ("Begin Performing Refresh on Adapt: %d with Ref Count: %d", pDhcpV6Adapt->dwIPv6IfIndex, pDhcpV6Adapt->uRefCount));

    AcquireExclusiveLock(&pDhcpV6Adapt->RWLock);
    if (pDhcpV6Adapt->DhcpV6State == dhcpv6_state_deinit) {
        dwError = ERROR_NOT_READY;
        DhcpV6Trace(DHCPV6_IOCTL, DHCPV6_LOG_LEVEL_WARN, ("WARN: Cannot refresh on Adapt: %d with Ref Count: %d since not in deinit state", pDhcpV6Adapt->dwIPv6IfIndex, pDhcpV6Adapt->uRefCount));
        BAIL_ON_LOCK_ERROR(dwError);
    }

    
#ifdef UNDER_CE
    wcstombs(szAdapterName, pDhcpV6Adapt->wszAdapterName,DHCPV6_MAX_NAME_SIZE);
    if (IsPDEnabledInterface(szAdapterName, NULL)) {
        pDhcpV6Adapt->Flags |= DHCPV6_PD_ENABLED_FL;
        bUsePD = TRUE;
    } else {
        pDhcpV6Adapt->Flags &= ~DHCPV6_PD_ENABLED_FL;
        bUsePD = FALSE;
    }

    if (! gbDHCPV6PDEnabled)
        bUsePD = FALSE;
    
#endif

    if (bUsePD) {

        if (pDhcpV6Adapt->pPdOption) {
            // set timeouts for confirm message
            SetInitialTimeout(pDhcpV6Adapt, DHCPV6_CNF_TIMEOUT, 
                DHCPV6_CNF_MAX_RT, 0);

            // goto rebind state.
            pDhcpV6Adapt->DhcpV6State = dhcpv6_state_rebindconfirm;

            // we use tickcounts here instead of the filetime
            // a little less hassle
            pDhcpV6Adapt->StartRebindConfirm = GetTickCount();

            dwError = DhcpV6TimerCancel(gpDhcpV6TimerModule, pDhcpV6Adapt);
            ASSERT(! dwError);

            // set timer/event to do work
            dwError = DhcpV6EventAddEvent(gpDhcpV6EventModule,
                pDhcpV6Adapt->dwIPv6IfIndex, DHCPV6MessageMgrTCallback,
                pDhcpV6Adapt, NULL);
            
            ASSERT(! dwError);
        } else {

            // no previous PD, so go to solicit mode
            SetInitialTimeout(pDhcpV6Adapt, DHCPV6_SOL_TIMEOUT, 
                DHCPV6_SOL_MAX_RT, 0);

            dwError = DhcpV6EventAddEvent(gpDhcpV6EventModule,
                pDhcpV6Adapt->dwIPv6IfIndex, DHCPV6MessageMgrSolicitCallback,
                pDhcpV6Adapt, NULL);

            ASSERT(! dwError);
        }

    } else {

        SetInitialTimeout(pDhcpV6Adapt, DHCPV6_INF_TIMEOUT,
            DHCPV6_INF_MAX_RT, 0);

        if (pDhcpV6Adapt->DhcpV6State == dhcpv6_state_request) {

            DhcpV6Trace(DHCPV6_IOCTL, DHCPV6_LOG_LEVEL_INFO, ("Adapter in already in request state - fire timer now"));

            dwError = DhcpV6TimerFireNow(gpDhcpV6TimerModule, pDhcpV6Adapt);
            BAIL_ON_LOCK_ERROR(dwError);

        } else {

            DhcpV6Trace(DHCPV6_IOCTL, DHCPV6_LOG_LEVEL_INFO, ("Adapter in already in configured state - ReStarting Info Request"));

            pDhcpV6Adapt->DhcpV6State = dhcpv6_state_init;

            if (pDhcpV6Adapt->bEventTimerQueued) {
                dwError = DhcpV6TimerCancel(gpDhcpV6TimerModule, pDhcpV6Adapt);
                ASSERT(! dwError);
            } else {
                ReferenceDHCPV6Adapt(pDhcpV6Adapt);
                bAdaptReference = TRUE;
            }

            dwError = DhcpV6EventAddEvent(
                            gpDhcpV6EventModule,
                            pDhcpV6Adapt->dwIPv6IfIndex,
                            DHCPV6MessageMgrInfoReqCallback,
                            pDhcpV6Adapt,
                            NULL
                            );

            ASSERT(! dwError);
            BAIL_ON_LOCK_ERROR(dwError);

        }

    }

    ReleaseExclusiveLock(&pDhcpV6Adapt->RWLock);

    return dwError;

lock:
    ReleaseExclusiveLock(&pDhcpV6Adapt->RWLock);

    if (bAdaptReference) {
        DereferenceDHCPV6Adapt(pDhcpV6Adapt);
    }

    DhcpV6Trace(DHCPV6_IOCTL, DHCPV6_LOG_LEVEL_ERROR, ("End Performing Refresh with Error: %!status!", dwError));

    return dwError;
}