zdshared.c

ZYDAS zd1211b driver for Linux2.4

#ifndef __ZDSHARED_C__
#define __ZDSHARED_C__

#include "zd80211.h"
#include "zddebug.h"
#include "zd1205.h"
extern struct net_device *g_dev;

void mkFragment(Signal_t *signal, FrmDesc_t *pfrmDesc, U8 *pEthHdr)
{
        struct zd1205_private *macp=g_dev->priv;
        Frame_t *mpdu, *curMpdu;
        FrmInfo_t *pfrmInfo;
        BOOLEAN bWep;
        U16 pdusize;
        U8 *pBody;
        U16 len;
        U8 fn;
        U8 *pByte;
        int i;
        Hash_t *pHash;
        MICvar *pTxMicKey = NULL;
        U8 KeyInstalled = 0;
        U8 vapId = 0;
        U8 Num;
        U8 bDataFrm = signal->bDataFrm;
        //U8 bDataFrm = pfrmDesc->bDataFrm;
        U16 HdrLen;

        ZDEBUG("mkFragment");
        pfrmDesc->CalMIC[MIC_LNG]=FALSE;
        pfrmInfo = &signal->frmInfo;
        pfrmInfo->frmDesc = pfrmDesc; //make connection for signal and frmDesc
        //PSDEBUG_V("mkFrag pfrmDesc", (U32)pfrmInfo->frmDesc);
        mpdu = pfrmDesc->mpdu;
        vapId = signal->vapId;
#if 0

        if (mDynKeyMode == DYN_KEY_TKIP || mDynKeyMode == DYN_KEY_AES) {
                if (bDataFrm) {
                        if (isGroup(addr1(mpdu))) {
                                KeyInstalled = mGkInstalled;

                                if (mDynKeyMode == DYN_KEY_TKIP) {
                                        pTxMicKey = &mBcMicKey;
                                        if (mWpaBcKeyLen != 32) // Not TKIP, don't make MIC
                                                KeyInstalled = 0;
                                }
                        } else { //unicast
                                pHash = HashSearch(addr1(mpdu));
                                if (!pHash) {
                                        FPRINT("HashSearch2 failed !!!");
                                        zd1205_dump_data("addr1 = ", (U8 *)addr1(mpdu), 6);
                                        KeyInstalled = 0;
                                } else {
                                        if (mDynKeyMode == DYN_KEY_TKIP)
                                                pTxMicKey = &pHash->TxMicKey;
                                        KeyInstalled = pHash->pkInstalled;
                                }
                        }

                        if ((KeyInstalled) && (mDynKeyMode == DYN_KEY_TKIP)) {
#endif
                                // The following section is used for TKIP-MIC append.
                                if (bDataFrm) {
                                        if (macp->cardSetting.WPAIeLen) // WPA is supported for now.
                                        {
                                                if (isGroup(addr1(mpdu)))
                                                {// Prepare to send the BC/MC packet.
                                                        KeyInstalled=mGkInstalled;
                                                        if (KeyInstalled) {
                                                                if(mWpaBcKeyLen == 32)
                                                                        pTxMicKey = &mBcMicKey;
                                                        } else
                                                                FPRINT("MkFrag: No Group key installed\n");
                                                } else
                                                {// Prepare to send the UC packet.
                                                        pHash = HashSearch(addr1(mpdu));
                                                        KeyInstalled=pHash->pkInstalled;
                                                        if (!pHash) {
                                                                FPRINT("HashSearch2 failed !!!");
                                                                zd1205_dump_data("addr1 = ", (U8 *)addr1(mpdu), 6);
                                                        } else if(KeyInstalled) {
                                                                //if (pHash->keyLength==32)
                                                                if (pHash->encryMode == TKIP)
                                                                        pTxMicKey = &pHash->TxMicKey;
                                                        } else {
                                                                FPRINT("MkFrag: Can't find Pairwise key\n");
                                                        }
                                                }

                                                if (pTxMicKey != NULL)
                                                { // This section is used for TKIP-MIC append.

                                                        U16 len = mpdu->bodyLen;

                                                        // calculate and append MIC to payload before fragmentation
                                                        MICclear(pTxMicKey);


                                                        if(mBssType == AP_BSS || mBssType==INDEPENDENT_BSS)
                                                                pByte = &mpdu->header[4]; //DA=Addr1
                                                        else //if (mBssType == INFRASTRUCTURE_BSS)
                                                                pByte = &mpdu->header[16];//DA=Addr3
                                                        for(i=0; i<6; i++) { //for DA
                                                                MICappendByte(*pByte++, pTxMicKey);
                                                        }

                                                        if(mBssType == INFRASTRUCTURE_BSS || mBssType==INDEPENDENT_BSS)
                                                                pByte = &mpdu->header[10]; //SA=Addr2
                                                        else //if (mBssType == AP_BSS)
                                                                pByte = &mpdu->header[16];
                                                        for(i=0; i<6; i++) { //for SA
                                                                MICappendByte(*pByte++, pTxMicKey);
                                                        }

                                                        MICappendByte(0, pTxMicKey);
                                                        MICappendByte(0, pTxMicKey);
                                                        MICappendByte(0, pTxMicKey);
                                                        MICappendByte(0, pTxMicKey);

                                                        pByte = mpdu->body;
                                                        for (i=0; i<len; i++) {
                                                                MICappendByte(*pByte++, pTxMicKey);
                                                        }
                                                        MICgetMIC(pfrmDesc->CalMIC, pTxMicKey);
                                                        pfrmDesc->CalMIC[MIC_LNG]=TRUE;
                                                        //zd1205_dump_data("add sw mic:",(u8*)pfrmDesc->CalMIC, 8);
                                                        mpdu->bodyLen += MIC_LNG;
                                                }
                                        }
                                }

                                bWep = mPrivacyInvoked;
                                if ((!bDataFrm) && (!(pfrmDesc->ConfigSet & FORCE_WEP_SET))) {
                                        bWep = FALSE;
                                } else {
                                        if (pfrmDesc->ConfigSet & EAPOL_FRAME_SET)
                                                bWep = FALSE;
                                }

                                if (KeyInstalled) // After pairwise key installed, even Eapol frame need to be encrypted
                                {
                                        bWep = TRUE;
                                } else {
                                        if (bDataFrm && !mKeyFormat && bWep) {
                                                printk(KERN_DEBUG "chkpnt 001\n");
                                                bWep = FALSE;
                                        }
                                }

                                pfrmInfo->eol = 0;

                                pdusize = mFragThreshold;
                                if ((!isGroup(addr1(mpdu))) && (mpdu->HdrLen + mpdu->bodyLen + CRC_LNG > pdusize)) { //Need fragment
                                        pdusize -= mpdu->HdrLen + CRC_LNG;
                                        pfrmInfo->fTot = (mpdu->bodyLen + (pdusize-1)) / pdusize;
                                        if (pfrmInfo->fTot == 0)
                                                pfrmInfo->fTot = 1;
                                } else {
                                        pdusize = mpdu->bodyLen;
                                        pfrmInfo->fTot = 1;
                                }

                                curMpdu = mpdu;
                                pBody = mpdu->body;
                                len = mpdu->bodyLen;
                                Num = pfrmInfo->fTot;
                                HdrLen = mpdu->HdrLen;

                                for (fn=0; fn<Num; fn++) {
                                        if (fn) {
                                                curMpdu = &pfrmDesc->mpdu[fn];
                                                memcpy(&curMpdu->header[0], &mpdu->header[0], HdrLen); //make header
                                                curMpdu->HdrLen = HdrLen;
                                                curMpdu->body = pBody;
                                        }
                                        curMpdu->header[22] = ((curMpdu->header[22] & 0xF0) | fn);

                                        if (fn == (Num - 1)) {
                                                curMpdu->bodyLen = len;
                                                curMpdu->header[1] &= ~MORE_FRAG_BIT;
                                        } else {
                                                curMpdu->bodyLen = pdusize;
                                                pBody += pdusize;
                                                len -= pdusize;
                                                curMpdu->header[1] |= MORE_FRAG_BIT;
                                        }

                                        if (bWep)
                                                curMpdu->header[1] |= WEP_BIT;
                                }
                        }


                        BOOLEAN sendMgtFrame(Signal_t *signal, FrmDesc_t *pfrmDesc) {
                                //	ZDEBUG("sendMgtFrame");
                                pfrmDesc->ConfigSet &= ~INTRA_BSS_SET;
                                pfrmDesc->ConfigSet &= ~EAPOL_FRAME_SET;
                                pfrmDesc->pHash = NULL;
                                pdot11Obj->ReleaseBuffer(signal->buf);
                                signal->buf = NULL;
                                signal->bDataFrm = 0;
                                //pfrmDesc->bDataFrm = 0;
                                mkFragment(signal, pfrmDesc, NULL);
                                return SendPkt(signal, pfrmDesc, TRUE);
                        }
#if 0
                        BOOLEAN	getElem(Frame_t	*frame, ElementID  eleID, Element  *elem) {
                                U8 k = 0; 	//offset bytes to first element
                                U8 n = 0; 	//num. of element


                                U8 pos;		//current position
                                U8 len;
                                U8 max_len=34;
                                switch (frmType(frame)) {
                                case ST_PROBE_REQ:
                                        k = 0;
                                        n = 4;
                                        if ((mDynKeyMode == DYN_KEY_TKIP) || (mDynKeyMode == DYN_KEY_AES))
                                                n++;
                                        break;

                                case ST_ASOC_REQ:

                                        k = 4;
                                        n = 4;
                                        if ((mDynKeyMode == DYN_KEY_TKIP) || (mDynKeyMode == DYN_KEY_AES))
                                                n++;
                                        break;

                                case ST_REASOC_REQ:
                                        k = 10;
                                        n = 4;
                                        if ((mDynKeyMode == DYN_KEY_TKIP) || (mDynKeyMode == DYN_KEY_AES))
                                                n++;
                                        break;

                                case ST_AUTH:
                                        k = 6;
                                        n = 1;
                                        max_len=130;
                                        break;

                                case ST_BEACON:
                                case ST_PROBE_RSP:
                                        k = 12;
                                        n = 6;

                                        if (mBssType == INDEPENDENT_BSS)
                                                n++;
                                        if ((mDynKeyMode == DYN_KEY_TKIP) || (mDynKeyMode == DYN_KEY_AES))
                                                n++;
                                        n++; //for country info
                                        break;

                                case ST_ASOC_RSP: