drivers/usb/net/Zydas/zdauthreq.c

   1 #ifndef __ZDAUTHREQ_C__
   2 #define __ZDAUTHREQ_C__
   3
   4 #include "zd80211.h"
   5
   6 U8 AuthReqState = STE_AUTH_REQ_IDLE;
   7 static MacAddr_t AuSta;
   8
   9
  10 BOOLEAN DeauthReq(Signal_t *signal)
  11 {
  12         FrmDesc_t *pfrmDesc;
  13         MacAddr_t Sta;
  14         ReasonCode Rsn = RC_UNSPEC_REASON;
  15         U8      vapId = 0;
  16
  17         ZDEBUG("DeauthReq");
  18
  19         memcpy((U8 *)&Sta, (U8 *)&signal->frmInfo.Sta, 6);
  20         Rsn = signal->frmInfo.rCode;
  21         pdot11Obj->StatusNotify(STA_DEAUTHED, (u8 *)&Sta);
  22
  23         vapId = signal->vapId;
  24         UpdateStaStatus(&Sta, STATION_STATE_NOT_AUTH, vapId);
  25
  26         pfrmDesc = allocFdesc();
  27         if(!pfrmDesc){
  28                 sigEnque(pMgtQ, (signal));
  29                 return FALSE;
  30         }
  31
  32         mkDisAssoc_DeAuthFrm(pfrmDesc, ST_DEAUTH, &Sta, Rsn, vapId);
  33         sendMgtFrame(signal, pfrmDesc);
  34
  35         return FALSE;
  36 }
  37
  38
  39 BOOLEAN AuthReq(Signal_t *signal)
  40 {
  41         FrmDesc_t *pfrmDesc;
  42         U8 vapId = 0;
  43         U16 auSC = SC_SUCCESSFUL;
  44
  45         //ZDEBUG("AuthReq");
  46         FPRINT("AuthReq");
  47         pfrmDesc = allocFdesc();
  48         if(!pfrmDesc){
  49         FPRINT("allocFdesc failed");
  50                 sigEnque(pMgtQ, (signal));
  51                 return FALSE;
  52         }
  53
  54         memcpy((U8 *)&AuSta, (U8 *)&signal->frmInfo.Sta, 6);
  55         //memcpy((U8 *)&AuSta, (U8 *)&mBssId, 6);
  56         mkAuthFrm(pfrmDesc, &AuSta, mAuthAlg, 1, auSC, NULL, vapId);
  57     //This fix is to prevent a deatuh from AP right after Auth success
  58     // that cause start_timer again. And crash the driver.
  59     pdot11Obj->StopTimer(DO_AUTH);
  60         pdot11Obj->StartTimer(AUTH_TIMEOUT, DO_AUTH);
  61         AuthReqState = STE_WAIT_AUTH_SEQ2;
  62         return sendMgtFrame(signal, pfrmDesc);
  63 }
  64
  65
  66 BOOLEAN AuthEven(Signal_t *signal)
  67 {
  68         FrmDesc_t *pfrmDesc;
  69         Frame_t *rdu;
  70         U16 auAlg;
  71         U16     auSeq;
  72         U16 auSC;
  73         U8 vapId = 0;
  74         MacAddr_t Sta;
  75         U8 ChalText[130];
  76
  77         //ZDEBUG("AuthEven");
  78         FPRINT("AuthEven");
  79         pfrmDesc = signal->frmInfo.frmDesc;
  80         rdu = pfrmDesc->mpdu;
  81         auSeq = authSeqNum(rdu);
  82         auAlg = authType(rdu);
  83         memcpy((U8 *)&Sta, (U8 *)addr2(rdu), 6);
  84         if (memcmp(&AuSta, &Sta, 6) != 0){
  85                 //FPRINT("Not for my Auth AP");
  86                 goto auth_release;
  87         }
  88
  89         if ((AuthReqState == STE_WAIT_AUTH_SEQ2) && (auSeq != 2)){
  90                 FPRINT("Seq!= 2");
  91                 goto auth_release;
  92         }
  93
  94         if ((AuthReqState == STE_WAIT_AUTH_SEQ4) && (auSeq != 4)){
  95                 FPRINT("Seq!= 4");
  96                 goto auth_release;
  97         }
  98
  99         auSC = authStatus(rdu);
 100         if (auSC != SC_SUCCESSFUL){
 101                 FPRINT("Auth Failed!!!");
 102                 FPRINT_V("Status Code", auSC);
 103                 goto auth_release;
 104         }
 105
 106         pdot11Obj->StopTimer(DO_AUTH);
 107         //FPRINT_V("auAlg", auAlg);
 108
 109         if (AuthReqState == STE_WAIT_AUTH_SEQ4){
 110                 UpdateStaStatus(&Sta, STATION_STATE_AUTH_KEY, vapId);
 111                 AuthReqState = STE_AUTH_REQ_IDLE;
 112
 113                 //do Assoicate
 114                 signal->id = SIG_ASSOC_REQ;
 115                 signal->block = BLOCK_ASOC;
 116                 sigEnque(pMgtQ, (signal));
 117                 freeFdesc(pfrmDesc);
 118                 return FALSE;
 119
 120         } else if (AuthReqState == STE_WAIT_AUTH_SEQ2){
 121                 if (auAlg == OPEN_SYSTEM){
 122                         FPRINT("Auth Success !!!");
 123                         UpdateStaStatus(&Sta, STATION_STATE_AUTH_OPEN, vapId);
 124                         AuthReqState = STE_AUTH_REQ_IDLE;
 125
 126                         //do Assoicate
 127                         signal->id = SIG_ASSOC_REQ;
 128                         signal->block = BLOCK_ASOC;
 129                         sigEnque(pMgtQ, (signal));
 130                         freeFdesc(pfrmDesc);
 131                         return FALSE;
 132                 }
 133
 134                 if (auAlg == SHARE_KEY){
 135                         if (!getElem(rdu, EID_CTEXT, (Element *)&ChalText[0],1)){
 136                                 FPRINT("Get ChalText failed");
 137                                 goto auth_release;
 138                         }
 139
 140                         FPRINT("Send Auth Seq 3 frame");
 141                         auSC = SC_SUCCESSFUL;
 142                         mkAuthFrm(pfrmDesc, &mBssId, mAuthAlg, 3, auSC, &ChalText[2], vapId);
 143                         pdot11Obj->StartTimer(AUTH_TIMEOUT, DO_AUTH);
 144                         AuthReqState = STE_WAIT_AUTH_SEQ4;
 145                         pfrmDesc->ConfigSet |= FORCE_WEP_SET;
 146                         return sendMgtFrame(signal, pfrmDesc);
 147                 }
 148         }
 149
 150 auth_release:
 151         FPRINT("auth_release");
 152         freeFdesc(pfrmDesc);
 153         return TRUE;
 154 }
 155
 156
 157 BOOLEAN AuthTimeOut(Signal_t *signal)
 158 {
 159         U8 vapId = 0;
 160         FPRINT("AuthTimeOut");
 161
 162         if      ((AuthReqState == STE_WAIT_AUTH_SEQ2) ||
 163
 164
 165                 (AuthReqState == STE_WAIT_AUTH_SEQ4)){
 166                 UpdateStaStatus(&mBssId, STATION_STATE_NOT_AUTH, vapId);
 167                 AuthReqState = STE_AUTH_REQ_IDLE;
 168         }
 169
 170         mRequestFlag |= CONNECT_TOUT_SET;
 171         return FALSE;
 172 }
 173
 174
 175 BOOLEAN AuthReqEntry(Signal_t *signal)
 176 {
 177         FrmDesc_t *pfrmDesc;
 178
 179         if (AuthReqState == STE_AUTH_REQ_IDLE){
 180                 switch(signal->id){
 181                         case SIG_DEAUTH_REQ:
 182                                 return DeauthReq(signal);
 183
 184                         case SIG_AUTH_REQ:
 185                                 return AuthReq(signal);
 186
 187                         default:
 188                                 goto auth_discard;
 189                 }
 190         }else if ((AuthReqState == STE_WAIT_AUTH_SEQ2) || (AuthReqState == STE_WAIT_AUTH_SEQ4)){
 191                 switch(signal->id){
 192             case SIG_DEAUTH_REQ:
 193                 goto auth_discard;//return TRUE;
 194
 195             case SIG_AUTH_REQ:
 196                                 goto auth_discard;//return TRUE;
 197
 198                         case SIG_AUTH_EVEN:
 199                                 return AuthEven(signal);
 200
 201                         case SIG_TO_AUTH:
 202                                 return AuthTimeOut(signal);
 203
 204                         default:
 205                                 goto auth_discard;
 206                 }
 207         } else
 208                 goto auth_discard;
 209
 210 auth_discard:
 211         pfrmDesc = signal->frmInfo.frmDesc;
 212         freeFdesc(pfrmDesc);
 213         return TRUE;
 214 }
 215 #endif