miniport.cxx

WinCE5.0部分核心源码

                        
                        pExt += (2 + eLen);                        
                    }

                    SVSUTIL_ASSERT(iUnkExtSize == 0);

                    // ** Add 802.1q header **
                    
                    if (p8021q) {
                        memcpy(p, p8021q, 4);
                        p += 2;
                        if (fOmitPayload) {
                            *p++ = 0x00; 
                            *p++ = 0x00;        
                        } else
                            p += 2;                       
                    }

                    // ** Add payload **

                    if (! fOmitPayload) {
                        memcpy (p, pData, cData);
                        p += cData;
                    }

                    SVSUTIL_ASSERT (p == pBuff->pBuffer + pBuff->cEnd);

                    gpPAN->AddRef ();
                    gpPAN->Unlock ();

                    IFDBG(DumpBnepPacket (L"Routing packet.", pBuff));

                    if (ERROR_SUCCESS != gpPAN->l2cap_if.l2ca_DataDown_In (gpPAN->hL2CAP, ConnToCtx (pConnForward), pConnForward->cid, pBuff)) {
                        if (pBuff->pFree)
                            pBuff->pFree (pBuff);
                    }

                    gpPAN->Lock ();
                    gpPAN->DelRef ();
                }
            }
        }
    }

    if (fBroad || fMCast || (fUnicast && (! fConsumerFound))) {
           if ((pAdapter->ulPacketFilter & NDIS_PACKET_TYPE_PROMISCUOUS)               ||
            (fBroad && (pAdapter->ulPacketFilter & NDIS_PACKET_TYPE_BROADCAST))     ||
            (fUnicast && (pAdapter->ulPacketFilter & NDIS_PACKET_TYPE_DIRECTED))    ||
            (fMCast && (pAdapter->ulPacketFilter & (NDIS_PACKET_TYPE_ALL_MULTICAST))) ||
            (fMCast && (pAdapter->ulPacketFilter & (NDIS_PACKET_TYPE_MULTICAST)) && (! FilterByMCast (&pAdapter->filter, pDestEther)))) {

            unsigned char *pBuff = (unsigned char *)LocalAlloc (LMEM_FIXED, sizeof(ETH_HDR) + cData);
            if (pBuff) {
                if (pAdapter->fAddressSet && (memcmp (pDestEther, gpPAN->eth, 6) == 0))
                    memcpy (pBuff, pAdapter->ethAddr, 6);
                else
                    memcpy (pBuff, pDestEther, 6);

                memcpy (pBuff + 6, pSrcEther, 6);
                pBuff[12] = uiNetType >> 8;
                pBuff[13] = uiNetType & 0xff;
                memcpy (pBuff + 14, pData, cData);

                if ((uiNetType == 0x0806) || (uiNetType == 0x8035))
                    ProcessArpData (pAdapter, pBuff + 14, cData);

                NDIS_PACKET *pPacket = NULL;
                NDIS_STATUS status;

                NdisAllocatePacket(&status, &pPacket, pAdapter->NdisPacketPool);
                if (status == NDIS_STATUS_SUCCESS) {
                    // Set OOB information
                    NDIS_SET_PACKET_HEADER_SIZE(pPacket, sizeof(ETH_HDR));

                    // Allocate buffer 
                    NDIS_BUFFER *pBuffer = NULL;
                    NdisAllocateBuffer (&status, &pBuffer, pAdapter->NdisBufferPool, pBuff, sizeof(ETH_HDR) + cData);
          
                    if (status == NDIS_STATUS_SUCCESS) {
                        // Chain allocated buffer to packet
                        NdisChainBufferAtFront(pPacket, pBuffer);

                        // Packet is ok, indicate it up      
                        NdisAdjustBufferLength(pBuffer, sizeof(ETH_HDR) + cData);
                        pPacket->Private.ValidCounts = FALSE;
                        NDIS_SET_PACKET_STATUS(pPacket, NDIS_STATUS_SUCCESS);
                        *(void **)&pPacket->MiniportReserved[0] = pBuff;

                        gpPAN->AddRef ();
                        gpPAN->Unlock ();

                        IFDBG(DebugOut (DEBUG_PAN_TRACE, L"ProcessEthernet :: indicating packet up\n"));

                        IFDBG(DebugOut (DEBUG_PAN_PACKETS, L"PACKET UP <ETHER>\n"));
                        DumpBuff (DEBUG_PAN_PACKETS, pBuff, sizeof(ETH_HDR) + cData);

                        NdisMIndicateReceivePacket(pAdapter->hAdapter, &pPacket, 1);

                        gpPAN->Lock ();
                        gpPAN->DelRef ();
                    } else {
                        IFDBG(DebugOut (DEBUG_ERROR, L"[PAN] ProcessEthernet :: OOM allocating buffer descriptor\n"));
                        NdisFreePacket (pPacket);
                        LocalFree (pBuff);
                    }
                } else {
                    IFDBG(DebugOut (DEBUG_ERROR, L"[PAN] ProcessEthernet :: OOM allocating packet descriptor\n"));
                    LocalFree (pBuff);
                }
            } else {
                IFDBG(DebugOut (DEBUG_ERROR, L"[PAN] ProcessEthernet :: OOM allocating buffer\n"));
            }
        }
    }

    pAdapter->DelRef ();

    IFDBG(DebugOut (DEBUG_PAN_TRACE, L"ProcessEthernet DONE\n"));
    return TRUE;
}

int RetryConnectionFilter (BTHPAN_CONNECTION *pConn, BD_BUFFER *pBuff) {
    SVSUTIL_ASSERT(gpPAN->IsLocked());    
                
    gpPAN->AddRef ();
    gpPAN->Unlock ();

    int iRes = gpPAN->l2cap_if.l2ca_DataDown_In (gpPAN->hL2CAP, ConnToCtx (pConn), pConn->cid, pBuff);

    gpPAN->Lock ();
    gpPAN->DelRef ();

    if (ERROR_SUCCESS != iRes) {
        if (pBuff->pFree)
            pBuff->pFree (pBuff);
    }

    return iRes;
}

// Need to retry sending filter at least once to pass PAN qualification
static DWORD WINAPI RetryNetConnectionFilter (LPVOID pvArg) {
    gpPAN->Lock ();

    BTHPAN_CONNECTION *pConn = ConnFromCtx (pvArg);
    if (pConn && (pConn->nAdapter != -1) && (pConn->state == UP)) {
        if (pConn->pNetFilterRetryBuff) {            
            IFDBG(DumpBnepPacket (L"Sending retry for net filter.", pConn->pNetFilterRetryBuff));            
            RetryConnectionFilter (pConn, pConn->pNetFilterRetryBuff);

            pConn->scNetFilter = btutil_ScheduleEvent (TimeoutConnection, ConnToCtx (pConn), BTHPAN_FILTER_RETRY_TO);

            pConn->pNetFilterRetryBuff = NULL;
        }

        pConn->scNetFilter = NULL;
    }

    gpPAN->Unlock ();

    return 0;
}

// Need to retry sending filter at least once to pass PAN qualification
static DWORD WINAPI RetryMCastConnectionFilter (LPVOID pvArg) {
    gpPAN->Lock ();

    BTHPAN_CONNECTION *pConn = ConnFromCtx (pvArg);
    if (pConn && (pConn->nAdapter != -1) && (pConn->state == UP)) {
        if (pConn->pMCastFilterRetryBuff) {            
            IFDBG(DumpBnepPacket (L"Sending retry for mcast filter.", pConn->pMCastFilterRetryBuff));            
            RetryConnectionFilter (pConn, pConn->pMCastFilterRetryBuff);

            pConn->scMCastFilter = btutil_ScheduleEvent (TimeoutConnection, ConnToCtx (pConn), BTHPAN_FILTER_RETRY_TO);

            pConn->pMCastFilterRetryBuff = NULL;
        }

        pConn->scMCastFilter = NULL;
    }

    gpPAN->Unlock ();

    return 0;       
}

static void SetConnectionFilter (BTHPAN_CONNECTION *pConn, FILTER_TYPE which) {
// Only one filter message can be outstanding at a time within a category.
    SVSUTIL_ASSERT (gpPAN->IsLocked ());

    if ((which == ALL) || (which == MCAST)) {
        if (pConn->fMCastMsgOut)
            pConn->fMCastMsgReq = TRUE;
    }

    if ((which == ALL) || (which == NETTYPE)) {
        if (pConn->fNetTypeMsgOut)
            pConn->fNetTypeMsgReq = TRUE;
    }

    if (((which == ALL) || (which == MCAST)) && (! pConn->fMCastMsgOut)) {
        pConn->fMCastMsgOut = TRUE;

        BD_BUFFER *pBuff = BufferAlloc (gpPAN->cDataHeaders + gpPAN->cDataTrailers + 4 + 12 * pConn->filter.cMCasts);
        if (pBuff) {
            pBuff->cStart = gpPAN->cDataHeaders;
            pBuff->cEnd   = pBuff->cSize - gpPAN->cDataTrailers;

            unsigned short usListSize = pConn->filter.cMCasts * 12;
            unsigned char *p = pBuff->pBuffer + pBuff->cStart;
            *p++ = 0x01;    // Control
            *p++ = 0x05;    // mcast filter
            *p++ = usListSize >> 8;      // Length
            *p++ = usListSize & 0xff;

            for (int i = 0 ; i < (int)pConn->filter.cMCasts ; ++i) {
                memcpy (p, &pConn->filter.amc[i].from, 6);
                p += 6;
                memcpy (p, &pConn->filter.amc[i].to, 6);
                p += 6;
            }

            SVSUTIL_ASSERT (p == pBuff->pBuffer + pBuff->cEnd);

            pConn->pMCastFilterRetryBuff = BufferCopy (pBuff);
            pConn->scMCastFilter = btutil_ScheduleEvent (RetryMCastConnectionFilter, ConnToCtx (pConn), BTHPAN_FILTER_RETRY_TO);

            gpPAN->AddRef ();
            gpPAN->Unlock ();

            IFDBG(DumpBnepPacket (L"Setting multicast filter.", pBuff));

            int iRes = gpPAN->l2cap_if.l2ca_DataDown_In (gpPAN->hL2CAP, ConnToCtx (pConn), pConn->cid, pBuff);

            gpPAN->Lock ();
            gpPAN->DelRef ();

            if (ERROR_SUCCESS != iRes) {
                if (pConn->scMCastFilter) {
                    btutil_UnScheduleEvent (pConn->scMCastFilter);
                    pConn->scMCastFilter = NULL;
                }
                if (pConn->pMCastFilterRetryBuff && pConn->pMCastFilterRetryBuff->pFree) {
                    pConn->pMCastFilterRetryBuff->pFree (pConn->pMCastFilterRetryBuff);
                    pConn->pMCastFilterRetryBuff = NULL;
                }
                if (pBuff->pFree)
                    pBuff->pFree (pBuff);
            }
        }
    }

    if (((which == ALL) || (which == NETTYPE)) && (! pConn->fNetTypeMsgOut)) {
        pConn->fNetTypeMsgOut = TRUE;

        BD_BUFFER *pBuff = BufferAlloc (gpPAN->cDataHeaders + gpPAN->cDataTrailers + 4 + 4 * pConn->filter.cNetTypes);
        if (pBuff) {
            pBuff->cStart = gpPAN->cDataHeaders;
            pBuff->cEnd   = pBuff->cSize - gpPAN->cDataTrailers;

            unsigned short usListSize = pConn->filter.cNetTypes * 4;
            unsigned char *p = pBuff->pBuffer + pBuff->cStart;
            *p++ = 0x01;    // Control
            *p++ = 0x03;    // mcast filter
            *p++ = usListSize >> 8;      // Length
            *p++ = usListSize & 0xff;

            for (int i = 0 ; i < (int)pConn->filter.cNetTypes ; ++i) {
                *p++ = pConn->filter.ant[i].from >> 8;
                *p++ = pConn->filter.ant[i].from & 0xff;
                *p++ = pConn->filter.ant[i].from >> 8;
                *p++ = pConn->filter.ant[i].from & 0xff;
            }

            SVSUTIL_ASSERT (p == pBuff->pBuffer + pBuff->cEnd);

            pConn->pNetFilterRetryBuff = BufferCopy (pBuff);
            pConn->scNetFilter = btutil_ScheduleEvent (RetryNetConnectionFilter, ConnToCtx (pConn), BTHPAN_FILTER_RETRY_TO);

            gpPAN->AddRef ();
            gpPAN->Unlock ();

            IFDBG(DumpBnepPacket (L"Setting net type filter.", pBuff));

            int iRes = gpPAN->l2cap_if.l2ca_DataDown_In (gpPAN->hL2CAP, ConnToCtx (pConn), pConn->cid, pBuff);

            gpPAN->Lock ();
            gpPAN->DelRef ();            

            if (ERROR_SUCCESS != iRes) {
                if (pConn->scNetFilter) {
                    btutil_UnScheduleEvent (pConn->scNetFilter);
                    pConn->scNetFilter = NULL;
                }
                if (pConn->pNetFilterRetryBuff && pConn->pNetFilterRetryBuff->pFree) {
                    pConn->pNetFilterRetryBuff->pFree (pConn->pNetFilterRetryBuff);
                    pConn->pNetFilterRetryBuff = NULL;
                }
                if (pBuff->pFree)
                    pBuff->pFree (pBuff);
            }
        }
    }
}

static DWORD WINAPI AuthenticatingThread (void *pvArg) {
    IFDBG(DebugOut (DEBUG_PAN_TRACE, L"Authenticating thread started for connection 0x%08x\n", pvArg));

    int fAuth = FALSE;
    int fEncr = FALSE;

    BT_ADDR bt;
    gpPAN->Lock ();
    BTHPAN_CONNECTION *pConn = ConnFromCtx (pvArg);
    if (pConn && ((pConn->state == CONFIG_SECURITY) || (pConn->state == CONFIG_BNEP)) && (pConn->nAdapter != -1)) {
        BTHPAN_ADAPTER *pAdapter = &gpPAN->aAdapters[pConn->nAdapter];
        bt = SET_NAP_SAP(pConn->ba.NAP, pConn->ba.SAP);
        fAuth = gpPAN->fAuthenticate && (! pConn->fAuthenticated);
        fEncr = gpPAN->fEncrypt && (! pConn->fEncrypted);
    } else
        pConn = NULL;

    gpPAN->Unlock ();

    if (! pConn) {
        IFDBG(DebugOut (DEBUG_PAN_TRACE, L"Authenticating thread for connection 0x%08x exiting without authentication\n", pvArg));
        return 0;
    }

    int iErr = ERROR_SUCCESS;

    if (fAuth)
        iErr = BthAuthenticate (&bt);

    if (fEncr && (iErr == ERROR_SUCCESS))
        iErr = BthSetEncryption (&bt, TRUE);

    gpPAN->Lock ();
    if (ConnFromCtx (pvArg) == pConn) {
        if (iErr != ERROR_SUCCESS) { // CloseConnection
            IFDBG(DebugOut (DEBUG_ERROR, L"[PAN] Authenticating for connection 0x%08x failed, error %d\n", pvArg, iErr));
            CloseConnection (pConn, NULL);
        } else {
            IFDBG(DebugOut (DEBUG_PAN_TRACE, L"Authenticating for connection 0x%08x successful. Connection UP.\n", pvArg));
            pConn->fAuthenticated = fAuth;
            pConn->fEncrypted = fEncr;

            if (pConn->state == CONFIG_SECURITY)
                pConn->state = UP;

            IFDBG(DebugOut (DEBUG_PAN_TRACE, L"Completing pending packets for authenticated connection.\n"));

            BTHPAN_ADAPTER *pAdapter = &gpPAN->aAdapters[pConn->nAdapter];
        
            BNEPPacket *pPacket = pConn->pPacketsPending;
            while (pConn->pPacketsPending) {
                BD_BUFFER *pBuff = pConn->pPacketsPending->pBuffer;
                pBuff->fMustCopy = TRUE;

                SVSUTIL_ASSERT(pBuff);                

                pAdapter->AddRef ();
                gpPAN->AddRef ();
                gpPAN->Unlock ();

                IFDBG(DumpBnepPacket (L"[PAN] Now sending pending packet:", pBuff));

                if (ERROR_SUCCESS != gpPAN->l2cap_if.l2ca_DataDown_In (gpPAN->hL2CAP, pvArg, pConn->cid, pBuff)) {
                    IFDBG(DebugOut (DEBUG_ERROR, L"[PAN] Connection 0x%08x - Error sending pending packet in authentication thread\n", pvArg));
                }

                gpPAN->Lock ();
                gpPAN->DelRef ();
                pAdapter->DelRef ();

                BNEPPacket *pFree = pConn->pPacketsPending;
                pConn->pPacketsPending = pConn->pPacketsPending->pNext;
                delete pFree;
            }

            if (pConn->state == UP)
                MpMediaStatusIndicate (pAdapter);

            if ((ConnFromCtx (pvArg) == pConn) && (pConn->state == UP))
                SetConnectionFilter (pConn, ALL);
        }
    } else {
        IFDBG(DebugOut (DEBUG_ERROR, L"[PAN] Connection 0x%08x disappeared in authentication thread\n", pvArg));
    }

    gpPAN->Unlock ();

    return 0;
}

static int StartAuthenticatingThread (BTHPAN_CONNECTION *pConn) {
    BTHPAN_ADAPTER *pAdapter =