zg_if.c

00001 
00002 /*
00003 Copyright (c) 2010 Donatien Garnier (donatiengar [at] gmail [dot] com)
00004  
00005 Permission is hereby granted, free of charge, to any person obtaining a copy
00006 of this software and associated documentation files (the "Software"), to deal
00007 in the Software without restriction, including without limitation the rights
00008 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00009 copies of the Software, and to permit persons to whom the Software is
00010 furnished to do so, subject to the following conditions:
00011  
00012 The above copyright notice and this permission notice shall be included in
00013 all copies or substantial portions of the Software.
00014  
00015 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00016 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00017 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00018 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00019 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00020 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00021 THE SOFTWARE.
00022 */
00023 
00024 #include "netCfg.h"
00025 #if NET_ZG2100
00026 
00027 #include "zg_defs.h"
00028 #include "zg_drv.h"
00029 #include "zg_if.h"
00030 
00031 //#define __DEBUG
00032 #include "dbg/dbg.h"
00033 
00034 #include "string.h"
00035 
00036 char m_ssid[ZG_SSID_LEN+1] = {0};
00037 zg_err connection_result = (zg_err)0; //Disc
00038 
00039 #ifdef __DEBUG
00040 /*inline*/ void hexdump(byte* buffer, int size) {
00041     for(int i = 0; i < size; ++i) {
00042         if((i%16)!=0) {
00043             DBG(" ");
00044         } else {
00045             DBG("%04X:  ", (i));
00046         }
00047         DBG("%02hhx", buffer[i]);
00048         if((i%16) ==  7) { 
00049             DBG(" ");
00050         }
00051         if((i%16) == 15) {
00052             DBG("\n");
00053         }
00054     }
00055     DBG("\n\n\n");
00056 }
00057 #else
00058 #define hexdump(a,b) 
00059 #endif
00060 
00061 void zg_scan(byte channel)
00062 {
00063   //Prepare request
00064   ZG_SCAN_REQ* req = (ZG_SCAN_REQ*)fifo_buf;
00065   memset((void*)req, 0, sizeof(ZG_SCAN_REQ));
00066   
00067   req->probe_delay = HTODS(ZG_SCAN_PROBE_DELAY);
00068   
00069   req->min_chan_time = HTODS(ZG_SCAN_MIN_CHAN_TIME);
00070   req->max_chan_time = HTODS(ZG_SCAN_MAX_CHAN_TIME);
00071   
00072   memset(req->bssid_mask, 0xFF, ZG_MACADDR_LEN); //Broadcast
00073   
00074   req->bss_type = ZG_BSS_ANY;
00075   req->probe_req = ZG_PROBE_ACTIVE;
00076   
00077   req->ssid_len = 0; //Do not filter by SSID
00078   
00079   req->channels_count = 1; //Scan on all ETSI channels (1~13)
00080   req->channels[0] = channel;
00081   
00082   //hexdump(fifo_buf, sizeof(ZG_SCAN_REQ));
00083   
00084   DBG("\r\n\r\n");
00085   
00086   //Send request
00087   zg_mgmt_req(ZG_FIFO_MGMT_SCAN, fifo_buf, sizeof(ZG_SCAN_REQ));
00088 }
00089 
00090 void zg_on_scan_results(byte* buf, int len)
00091 {
00092   int i;
00093   int j;
00094   uint32_t rate;
00095   char ssid[ZG_SSID_LEN + 1];
00096   ZG_SCAN_ITEM* it;
00097   //Get result header
00098   ZG_SCAN_RES* res = (ZG_SCAN_RES*)buf;
00099   
00100   //hexdump(buf, len);
00101   
00102   DBG("\r\nScan result %d, with %d networks found\n", 
00103   res->result, res->results_count);
00104   
00105   if( res->result != 1 )
00106   {
00107     return; //Error
00108   }
00109   it = (ZG_SCAN_ITEM*)(buf + sizeof(ZG_SCAN_RES));
00110   for( i = 0; i < res->results_count; i++ )
00111   {
00112     //Display info
00113     DBG("\r\n---Result #%2d---\n",i+1);
00114     
00115     memset(ssid, 0, ZG_SSID_LEN + 1);
00116     memcpy(ssid, it->ssid, it->ssid_len);
00117     DBG("SSID : %s\n", ssid);
00118 
00119     DBG("BSSID : %02x:%02x:%02x:%02x:%02x:%02x\n", 
00120     it->bssid[0], it->bssid[1], it->bssid[2],
00121     it->bssid[3], it->bssid[4], it->bssid[5]);
00122     
00123     DBG("Supported rates : ");
00124     for( j = 0; j < it->supported_rates_count; j++ )
00125     {
00126       rate = it->supported_rates[j];
00127       rate = rate * 500;
00128       DBG("%u Kbps; ", rate);
00129     }
00130     DBG("\n");
00131     
00132     DBG("RSSI : %d\n", it->rssi);
00133     DBG("Channel : %d\n", it->channel);
00134     DBG("Type : %d\n", it->bss_type);
00135     
00136     DBG("---------------\n");
00137     
00138     it++; //Next result
00139   }
00140 }
00141 
00142 void zg_set_ssid(const char* ssid)
00143 {
00144   strcpy(m_ssid, ssid);
00145 }
00146 
00147 void zg_set_wep_key(const byte* key, int len)
00148 {
00149   //Write 4 wep keys
00150   ZG_WEP_REQ* req = (ZG_WEP_REQ*)fifo_buf;
00151   memset((void*)req, 0, sizeof(ZG_WEP_REQ));
00152   
00153   req->slot = 3; //WEP key slot
00154   
00155   req->key_size = len; //FIXME: Assert 5 or 13 bytes long  
00156   req->default_key = 0;
00157   
00158   strncpy(req->ssid, m_ssid, ZG_SSID_LEN);
00159   req->ssid_len = strlen(m_ssid);
00160   
00161   memcpy((void*)req->keys, key, len);
00162   
00163   //Send request
00164   zg_mgmt_req(ZG_FIFO_MGMT_WEP_KEY, fifo_buf, sizeof(ZG_WEP_REQ));
00165 }
00166 
00167 void zg_set_wpa_pass(const char* pass)
00168 {
00169   //Compute PNK key with this passphrase
00170   //On completion, zg_on_psk_key will be called
00171   ZG_PSK_CALC_REQ* req = (ZG_PSK_CALC_REQ*)fifo_buf;
00172   memset((void*)req, 0, sizeof(ZG_PSK_CALC_REQ));
00173   
00174   req->config = 0;
00175   
00176   req->phrase_len = strlen(pass);
00177   
00178   strncpy(req->ssid, m_ssid, ZG_SSID_LEN);
00179   req->ssid_len = strlen(m_ssid);
00180   
00181   strncpy(req->pass_phrase, pass, ZG_WPA_PASS_LEN);
00182   
00183   //Send request
00184   zg_mgmt_req(ZG_FIFO_MGMT_PSK_CALC, fifo_buf, sizeof(ZG_PSK_CALC_REQ));
00185 }
00186 
00187 void zg_on_psk_key(byte* buf, int len)
00188 {
00189   //Now the key has been computed and we can write it
00190   ZG_PSK_CALC_RES* res = (ZG_PSK_CALC_RES*) buf;
00191   if( (res->result != 1) || (res->key_returned != 1) )
00192   {
00193     DBG("Could not compute key, error %d\n", res->result);
00194     return; //Error
00195   }
00196   
00197   DBG("PMK key is :\n");
00198   hexdump(res->key, ZG_PMK_LEN);
00199   
00200   byte key[ZG_PMK_LEN];
00201   memcpy(key, res->key, ZG_PMK_LEN);
00202   
00203   //Send next request
00204   zg_set_psk_key(key, ZG_PMK_LEN);
00205 }
00206 
00207 void zg_set_psk_key(const byte* key, int len)
00208 {
00209   ZG_PMK_REQ* req = (ZG_PMK_REQ*)fifo_buf;
00210   memset((void*)req, 0, sizeof(ZG_PMK_REQ));
00211   
00212   req->slot = 0; //WPA/WPA2 PSK slot
00213   
00214   strncpy(req->ssid, m_ssid, ZG_SSID_LEN);
00215   req->ssid_len = strlen(m_ssid);
00216   
00217   memcpy(req->key, key, ZG_PMK_LEN);
00218 
00219   //Send request
00220   zg_mgmt_req(ZG_FIFO_MGMT_PMK_KEY, fifo_buf, sizeof(ZG_FIFO_MGMT_PMK_KEY)); 
00221 }
00222 
00223 void zg_connect(ZG_BSS_TYPE type, ZG_SECURITY security)
00224 {
00225   ZG_CONNECT_REQ* req = (ZG_CONNECT_REQ*)fifo_buf;
00226   memset((void*)req, 0, sizeof(ZG_CONNECT_REQ));
00227   
00228   req->security = security;
00229   
00230   strncpy(req->ssid, m_ssid, ZG_SSID_LEN);
00231   req->ssid_len = strlen(m_ssid);
00232   
00233   req->sleep_duration = HTODS( 0 );
00234   
00235   req->bss_type = type;
00236   
00237   //Send request
00238   zg_mgmt_req(ZG_FIFO_MGMT_CONNECT, fifo_buf, sizeof(ZG_CONNECT_REQ)); 
00239 }
00240 
00241 void zg_on_connect(zg_err result)
00242 {
00243   connection_result = result;
00244 }
00245 
00246 zg_err zg_get_connection_result()
00247 {
00248   return connection_result;
00249 }
00250 
00251 void zg_disconnect()
00252 {
00253   ZG_DISCONNECT_REQ* req = (ZG_DISCONNECT_REQ*)fifo_buf;
00254   memset((void*)req, 0, sizeof(ZG_DISCONNECT_REQ));
00255   
00256   req->reason_code = HTODS( 0 );
00257   req->disconnect = true;
00258   req->deauth_frame = true;
00259     
00260   //Send request
00261   zg_mgmt_req(ZG_FIFO_MGMT_DISC, fifo_buf, sizeof(ZG_DISCONNECT_REQ)); 
00262   
00263   connection_result = (zg_err)0;
00264 }
00265 
00266 #endif