1 /*
2 * WPA Supplicant - Driver interaction with Atmel Wireless LAN drivers
3 * Copyright (c) 2000-2005, ATMEL Corporation
4 * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * Alternatively, this software may be distributed under the terms of BSD
11 * license.
12 *
13 * See README and COPYING for more details.
14 */
15
16 /******************************************************************************
17 Copyright 2000-2001 ATMEL Corporation.
18
19 WPA Supplicant - driver interaction with Atmel Wireless lan drivers.
20
21 This is free software; you can redistribute it and/or modify
22 it under the terms of the GNU General Public License as published by
23 the Free Software Foundation; either version 2 of the License, or
24 (at your option) any later version.
25
26 This program is distributed in the hope that it will be useful,
27 but WITHOUT ANY WARRANTY; without even the implied warranty of
28 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 GNU General Public License for more details.
30
31 You should have received a copy of the GNU General Public License
32 along with Atmel wireless lan drivers; if not, write to the Free Software
33 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34
35 ******************************************************************************/
36
37 /*
38 * Alternatively, this software may be distributed under the terms of BSD
39 * license.
40 */
41
42 #include "includes.h"
43 #include <sys/ioctl.h>
44
45 #include "wireless_copy.h"
46 #include "common.h"
47 #include "driver.h"
48 #include "driver_wext.h"
49 #include "wpa_supplicant.h"
50
51 struct wpa_driver_atmel_data {
52 void *wext; /* private data for driver_wext */
53 void *ctx;
54 char ifname[IFNAMSIZ + 1];
55 int sock;
56 };
57
58
59 #define ATMEL_WPA_IOCTL (SIOCIWFIRSTPRIV + 2)
60 #define ATMEL_WPA_IOCTL_PARAM (SIOCIWFIRSTPRIV + 3)
61 #define ATMEL_WPA_IOCTL_GET_PARAM (SIOCIWFIRSTPRIV + 4)
62
63
64 /* ATMEL_WPA_IOCTL ioctl() cmd: */
65 enum {
66 SET_WPA_ENCRYPTION = 1,
67 SET_CIPHER_SUITES = 2,
68 MLME_STA_DEAUTH = 3,
69 MLME_STA_DISASSOC = 4
70 };
71
72 /* ATMEL_WPA_IOCTL_PARAM ioctl() cmd: */
73 enum {
74 ATMEL_PARAM_WPA = 1,
75 ATMEL_PARAM_PRIVACY_INVOKED = 2,
76 ATMEL_PARAM_WPA_TYPE = 3
77 };
78
79 #define MAX_KEY_LENGTH 40
80
81 struct atmel_param{
82 unsigned char sta_addr[6];
83 int cmd;
84 u8 alg;
85 u8 key_idx;
86 u8 set_tx;
87 u8 seq[8];
88 u8 seq_len;
89 u16 key_len;
90 u8 key[MAX_KEY_LENGTH];
91 struct{
92 int reason_code;
93 u8 state;
94 }mlme;
95 u8 pairwise_suite;
96 u8 group_suite;
97 u8 key_mgmt_suite;
98 };
99
100
101
atmel_ioctl(struct wpa_driver_atmel_data * drv,struct atmel_param * param,int len,int show_err)102 static int atmel_ioctl(struct wpa_driver_atmel_data *drv,
103 struct atmel_param *param,
104 int len, int show_err)
105 {
106 struct iwreq iwr;
107
108 os_memset(&iwr, 0, sizeof(iwr));
109 os_strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
110 iwr.u.data.pointer = (caddr_t) param;
111 iwr.u.data.length = len;
112
113 if (ioctl(drv->sock, ATMEL_WPA_IOCTL, &iwr) < 0) {
114 int ret;
115 ret = errno;
116 if (show_err)
117 perror("ioctl[ATMEL_WPA_IOCTL]");
118 return ret;
119 }
120
121 return 0;
122 }
123
124
atmel2param(struct wpa_driver_atmel_data * drv,int param,int value)125 static int atmel2param(struct wpa_driver_atmel_data *drv, int param, int value)
126 {
127 struct iwreq iwr;
128 int *i, ret = 0;
129
130 os_memset(&iwr, 0, sizeof(iwr));
131 os_strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
132 i = (int *) iwr.u.name;
133 *i++ = param;
134 *i++ = value;
135
136 if (ioctl(drv->sock, ATMEL_WPA_IOCTL_PARAM, &iwr) < 0) {
137 perror("ioctl[ATMEL_WPA_IOCTL_PARAM]");
138 ret = -1;
139 }
140 return ret;
141 }
142
143
144 #if 0
145 static int wpa_driver_atmel_set_wpa_ie(struct wpa_driver_atmel_data *drv,
146 const char *wpa_ie, size_t wpa_ie_len)
147 {
148 struct atmel_param *param;
149 int res;
150 size_t blen = ATMEL_GENERIC_ELEMENT_HDR_LEN + wpa_ie_len;
151 if (blen < sizeof(*param))
152 blen = sizeof(*param);
153
154 param = os_zalloc(blen);
155 if (param == NULL)
156 return -1;
157
158 param->cmd = ATMEL_SET_GENERIC_ELEMENT;
159 param->u.generic_elem.len = wpa_ie_len;
160 os_memcpy(param->u.generic_elem.data, wpa_ie, wpa_ie_len);
161 res = atmel_ioctl(drv, param, blen, 1);
162
163 os_free(param);
164
165 return res;
166 }
167 #endif
168
169
wpa_driver_atmel_set_wpa(void * priv,int enabled)170 static int wpa_driver_atmel_set_wpa(void *priv, int enabled)
171 {
172 struct wpa_driver_atmel_data *drv = priv;
173 int ret = 0;
174
175 printf("wpa_driver_atmel_set_wpa %s\n", drv->ifname);
176
177 wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
178
179 #if 0
180 if (!enabled && wpa_driver_atmel_set_wpa_ie(drv, NULL, 0) < 0)
181 ret = -1;
182 #endif
183 if (atmel2param(drv, ATMEL_PARAM_PRIVACY_INVOKED, enabled) < 0)
184 ret = -1;
185 if (atmel2param(drv, ATMEL_PARAM_WPA, enabled) < 0)
186 ret = -1;
187
188 return ret;
189 }
190
191
wpa_driver_atmel_set_key(void * priv,wpa_alg alg,const u8 * addr,int key_idx,int set_tx,const u8 * seq,size_t seq_len,const u8 * key,size_t key_len)192 static int wpa_driver_atmel_set_key(void *priv, wpa_alg alg,
193 const u8 *addr, int key_idx,
194 int set_tx, const u8 *seq, size_t seq_len,
195 const u8 *key, size_t key_len)
196 {
197 struct wpa_driver_atmel_data *drv = priv;
198 int ret = 0;
199 struct atmel_param *param;
200 u8 *buf;
201 u8 alg_type;
202
203 size_t blen;
204 char *alg_name;
205
206 switch (alg) {
207 case WPA_ALG_NONE:
208 alg_name = "none";
209 alg_type = 0;
210 break;
211 case WPA_ALG_WEP:
212 alg_name = "WEP";
213 alg_type = 1;
214 break;
215 case WPA_ALG_TKIP:
216 alg_name = "TKIP";
217 alg_type = 2;
218 break;
219 case WPA_ALG_CCMP:
220 alg_name = "CCMP";
221 alg_type = 3;
222 break;
223 default:
224 return -1;
225 }
226
227 wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%lu "
228 "key_len=%lu", __FUNCTION__, alg_name, key_idx, set_tx,
229 (unsigned long) seq_len, (unsigned long) key_len);
230
231 if (seq_len > 8)
232 return -2;
233
234 blen = sizeof(*param) + key_len;
235 buf = os_zalloc(blen);
236 if (buf == NULL)
237 return -1;
238
239 param = (struct atmel_param *) buf;
240
241 param->cmd = SET_WPA_ENCRYPTION;
242
243 if (addr == NULL)
244 os_memset(param->sta_addr, 0xff, ETH_ALEN);
245 else
246 os_memcpy(param->sta_addr, addr, ETH_ALEN);
247
248 param->alg = alg_type;
249 param->key_idx = key_idx;
250 param->set_tx = set_tx;
251 os_memcpy(param->seq, seq, seq_len);
252 param->seq_len = seq_len;
253 param->key_len = key_len;
254 os_memcpy((u8 *)param->key, key, key_len);
255
256 if (atmel_ioctl(drv, param, blen, 1)) {
257 wpa_printf(MSG_WARNING, "Failed to set encryption.");
258 /* TODO: show key error*/
259 ret = -1;
260 }
261 os_free(buf);
262
263 return ret;
264 }
265
266
wpa_driver_atmel_set_countermeasures(void * priv,int enabled)267 static int wpa_driver_atmel_set_countermeasures(void *priv,
268 int enabled)
269 {
270 /* FIX */
271 printf("wpa_driver_atmel_set_countermeasures - not yet "
272 "implemented\n");
273 return 0;
274 }
275
276
wpa_driver_atmel_set_drop_unencrypted(void * priv,int enabled)277 static int wpa_driver_atmel_set_drop_unencrypted(void *priv,
278 int enabled)
279 {
280 /* FIX */
281 printf("wpa_driver_atmel_set_drop_unencrypted - not yet "
282 "implemented\n");
283 return 0;
284 }
285
286
wpa_driver_atmel_mlme(void * priv,const u8 * addr,int cmd,int reason_code)287 static int wpa_driver_atmel_mlme(void *priv, const u8 *addr, int cmd,
288 int reason_code)
289 {
290 struct wpa_driver_atmel_data *drv = priv;
291 struct atmel_param param;
292 int ret;
293 int mgmt_error = 0xaa;
294
295 os_memset(¶m, 0, sizeof(param));
296 os_memcpy(param.sta_addr, addr, ETH_ALEN);
297 param.cmd = cmd;
298 param.mlme.reason_code = reason_code;
299 param.mlme.state = mgmt_error;
300 ret = atmel_ioctl(drv, ¶m, sizeof(param), 1);
301 return ret;
302 }
303
304
305 #if 0
306 static int wpa_driver_atmel_set_suites(struct wpa_driver_atmel_data *drv,
307 u8 pairwise_suite, u8 group_suite,
308 u8 key_mgmt_suite)
309 {
310 struct atmel_param param;
311 int ret;
312
313 os_memset(¶m, 0, sizeof(param));
314 param.cmd = SET_CIPHER_SUITES;
315 param.pairwise_suite = pairwise_suite;
316 param.group_suite = group_suite;
317 param.key_mgmt_suite = key_mgmt_suite;
318
319 ret = atmel_ioctl(drv, ¶m, sizeof(param), 1);
320 return ret;
321 }
322 #endif
323
324
wpa_driver_atmel_deauthenticate(void * priv,const u8 * addr,int reason_code)325 static int wpa_driver_atmel_deauthenticate(void *priv, const u8 *addr,
326 int reason_code)
327 {
328 struct wpa_driver_atmel_data *drv = priv;
329 printf("wpa_driver_atmel_deauthenticate\n");
330 wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
331 return wpa_driver_atmel_mlme(drv, addr, MLME_STA_DEAUTH,
332 reason_code);
333
334 }
335
336
wpa_driver_atmel_disassociate(void * priv,const u8 * addr,int reason_code)337 static int wpa_driver_atmel_disassociate(void *priv, const u8 *addr,
338 int reason_code)
339 {
340 struct wpa_driver_atmel_data *drv = priv;
341 printf("wpa_driver_atmel_disassociate\n");
342 wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
343 return wpa_driver_atmel_mlme(drv, addr, MLME_STA_DISASSOC,
344 reason_code);
345
346 }
347
348
349 #if 0
350 /* Atmel driver uses specific values for each cipher suite */
351 static int convertSuiteToDriver(wpa_cipher suite)
352 {
353 u8 suite_type;
354
355 switch(suite) {
356 case CIPHER_NONE:
357 suite_type = 0;
358 break;
359 case CIPHER_WEP40:
360 suite_type = 1;
361 break;
362 case CIPHER_TKIP:
363 suite_type = 2;
364 break;
365 case CIPHER_WEP104:
366 suite_type = 5;
367 break;
368 case CIPHER_CCMP:
369 suite_type = 3;
370 break;
371 default:
372 suite_type = 2;
373 }
374
375 return suite_type;
376
377 }
378 #endif
379
380 static int
wpa_driver_atmel_associate(void * priv,struct wpa_driver_associate_params * params)381 wpa_driver_atmel_associate(void *priv,
382 struct wpa_driver_associate_params *params)
383 {
384 struct wpa_driver_atmel_data *drv = priv;
385 int ret = 0;
386 #if 0
387 u8 pairwise_suite_driver;
388 u8 group_suite_driver;
389 u8 key_mgmt_suite_driver;
390
391 pairwise_suite_driver = convertSuiteToDriver(params->pairwise_suite);
392 group_suite_driver = convertSuiteToDriver(params->group_suite);
393 key_mgmt_suite_driver = convertSuiteToDriver(params->key_mgmt_suite);
394
395 if (wpa_driver_atmel_set_suites(drv, pairwise_suite_driver,
396 group_suite_driver,
397 key_mgmt_suite_driver) < 0){
398 printf("wpa_driver_atmel_set_suites.\n");
399 ret = -1;
400 }
401 if (wpa_driver_wext_set_freq(drv->wext, params->freq) < 0) {
402 printf("wpa_driver_atmel_set_freq.\n");
403 ret = -1;
404 }
405 #endif
406 if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len)
407 < 0) {
408 printf("FAILED : wpa_driver_atmel_set_ssid.\n");
409 ret = -1;
410 }
411 if (wpa_driver_wext_set_bssid(drv->wext, params->bssid) < 0) {
412 printf("FAILED : wpa_driver_atmel_set_bssid.\n");
413 ret = -1;
414 }
415
416 return ret;
417 }
418
419
wpa_driver_atmel_get_bssid(void * priv,u8 * bssid)420 static int wpa_driver_atmel_get_bssid(void *priv, u8 *bssid)
421 {
422 struct wpa_driver_atmel_data *drv = priv;
423 return wpa_driver_wext_get_bssid(drv->wext, bssid);
424 }
425
426
wpa_driver_atmel_get_ssid(void * priv,u8 * ssid)427 static int wpa_driver_atmel_get_ssid(void *priv, u8 *ssid)
428 {
429 struct wpa_driver_atmel_data *drv = priv;
430 return wpa_driver_wext_get_ssid(drv->wext, ssid);
431 }
432
433
wpa_driver_atmel_scan(void * priv,const u8 * ssid,size_t ssid_len)434 static int wpa_driver_atmel_scan(void *priv, const u8 *ssid, size_t ssid_len)
435 {
436 struct wpa_driver_atmel_data *drv = priv;
437 return wpa_driver_wext_scan(drv->wext, ssid, ssid_len);
438 }
439
440
wpa_driver_atmel_get_scan_results(void * priv,struct wpa_scan_result * results,size_t max_size)441 static int wpa_driver_atmel_get_scan_results(void *priv,
442 struct wpa_scan_result *results,
443 size_t max_size)
444 {
445 struct wpa_driver_atmel_data *drv = priv;
446 return wpa_driver_wext_get_scan_results(drv->wext, results, max_size);
447 }
448
449
wpa_driver_atmel_set_operstate(void * priv,int state)450 static int wpa_driver_atmel_set_operstate(void *priv, int state)
451 {
452 struct wpa_driver_atmel_data *drv = priv;
453 return wpa_driver_wext_set_operstate(drv->wext, state);
454 }
455
456
wpa_driver_atmel_init(void * ctx,const char * ifname)457 static void * wpa_driver_atmel_init(void *ctx, const char *ifname)
458 {
459 struct wpa_driver_atmel_data *drv;
460
461 drv = os_zalloc(sizeof(*drv));
462 if (drv == NULL)
463 return NULL;
464 drv->wext = wpa_driver_wext_init(ctx, ifname);
465 if (drv->wext == NULL) {
466 os_free(drv);
467 return NULL;
468 }
469
470 drv->ctx = ctx;
471 os_strncpy(drv->ifname, ifname, sizeof(drv->ifname));
472 drv->sock = socket(PF_INET, SOCK_DGRAM, 0);
473 if (drv->sock < 0) {
474 wpa_driver_wext_deinit(drv->wext);
475 os_free(drv);
476 return NULL;
477 }
478
479 return drv;
480 }
481
482
wpa_driver_atmel_deinit(void * priv)483 static void wpa_driver_atmel_deinit(void *priv)
484 {
485 struct wpa_driver_atmel_data *drv = priv;
486 wpa_driver_wext_deinit(drv->wext);
487 close(drv->sock);
488 os_free(drv);
489 }
490
491
492 const struct wpa_driver_ops wpa_driver_atmel_ops = {
493 .name = "atmel",
494 .desc = "ATMEL AT76C5XXx (USB, PCMCIA)",
495 .get_bssid = wpa_driver_atmel_get_bssid,
496 .get_ssid = wpa_driver_atmel_get_ssid,
497 .set_wpa = wpa_driver_atmel_set_wpa,
498 .set_key = wpa_driver_atmel_set_key,
499 .init = wpa_driver_atmel_init,
500 .deinit = wpa_driver_atmel_deinit,
501 .set_countermeasures = wpa_driver_atmel_set_countermeasures,
502 .set_drop_unencrypted = wpa_driver_atmel_set_drop_unencrypted,
503 .scan = wpa_driver_atmel_scan,
504 .get_scan_results = wpa_driver_atmel_get_scan_results,
505 .deauthenticate = wpa_driver_atmel_deauthenticate,
506 .disassociate = wpa_driver_atmel_disassociate,
507 .associate = wpa_driver_atmel_associate,
508 .set_operstate = wpa_driver_atmel_set_operstate,
509 };
510