#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:
		case ST_REASOC_RSP:
			k = 6;
			n = 2;
       
			if ((mDynKeyMode == DYN_KEY_TKIP) || (mDynKeyMode == DYN_KEY_AES))		
				n++;
			break;	
			
		default:
			elem->buf[1] = 0;
			return FALSE;	
	}

	//while(n--){
        while(k < frame->bodyLen)
        {
		pos = frame->body[k]; 
		len = frame->body[k+1] + 2;
		
		if ((pos == eleID) && (len <= max_len))
		{	//match
                        if (eleID == EID_WPA) //Valid WPA IE 
			{
			    if (len > 20)
			    {
				memcpy((U8 *)elem, &frame->body[k], len);
				return TRUE;
			    }
			    else
                                k += len;
			}
			else
			{
			    memcpy((U8 *)elem, &frame->body[k], len);
			    return TRUE;
                        }
		}
		else{
			k += len;
		}
	}

	elem->buf[1] = 0; //set element length to zero
	return FALSE;
}
#endif
BOOLEAN getElem(Frame_t *frame, ElementID  eleID, Element  *elem, U8 eleOrder)
{
    U8 k = 0; 	//offset bytes to first element
    U8 pos;		//current position
    U8 len;
    U8 max_len = 130;
    U8 eleCount = 0;

    switch (frmType(frame)){
        case ST_PROBE_REQ:
            k = 0;
            break;

        case ST_ASOC_REQ:
            k = 4;
            break;

        case ST_REASOC_REQ:
            k = 10;
            break;

        case ST_AUTH:
            k = 6;
            break;	

        case ST_BEACON:	
        case ST_PROBE_RSP:
            k = 12;
            break;	

        case ST_ASOC_RSP:
        case ST_REASOC_RSP:
            k = 6;
            break;	

        default:
            elem->buf[1] = 0;
            return FALSE;	
    }

    //jxiao
    while (k < frame->bodyLen)
    {
        pos=frame->body[k];
        len=frame->body[k+1]+2;
        if ((pos==eleID) && (len <= max_len))
        {
            eleCount ++;
            if(eleCount < eleOrder)
            {
                k+= len;
                continue;
            }
            memcpy((U8 *)elem, &frame->body[k], len);
            return TRUE;
        }
        else
        {  
            k += len;
        }
    }
    elem->buf[1]=0;
    return FALSE;
}

void mkAuthFrm(FrmDesc_t* pfrmDesc, MacAddr_t *addr1, U16 Alg, U16 Seq, 
        U16 Status, U8 *pChalng, U8 vapId)
{
    U8 *body;
    U16 len;
    Frame_t *pf = pfrmDesc->mpdu;

    setFrameType(pf, ST_AUTH);
    pf->body = pfrmDesc->buffer;
    body = pf->body;
    setAddr1(pf, addr1);
    setAddr2(pf, &dot11MacAddress);
    setAddr3(pf, &mBssId);
    pf->HdrLen = MAC_HDR_LNG;		

    body[0] = Alg & 0xff;			//AuthAlg
    body[1] = (Alg & 0xff00) >> 8;
    body[2] = Seq & 0xff;			//AuthSeq