← Back to branch summary

~ubuntu-branches/ubuntu/saucy/wpasupplicant/saucy

« back to all changes in this revision

Viewing changes to src/drivers/driver_broadcom.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Trudel-Lapierre
  • Date: 2010-11-22 09:43:43 UTC
  • mfrom: (1.1.16 upstream)
  • Revision ID: james.westby@ubuntu.com-20101122094343-qgsxaojvmswfri77
Tags: 0.7.3-0ubuntu1
* Get wpasupplicant 0.7.3 from Debian's SVN. Leaving 0.7.3-1 as unreleased
  for now.
* Build-Depend on debhelper 8, since the packaging from Debian uses compat 8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/drivers/driver_broadcom.c
162
162
        return 0;
163
163
}
164
164
 
165
 
static int wpa_driver_broadcom_set_key(void *priv, wpa_alg alg,
 
165
static int wpa_driver_broadcom_set_key(const char *ifname, void *priv,
 
166
                                       enum wpa_alg alg,
166
167
                                       const u8 *addr, int key_idx, int set_tx,
167
168
                                       const u8 *seq, size_t seq_len,
168
169
                                       const u8 *key, size_t key_len)
232
233
        int left;
233
234
        wl_wpa_header_t *wwh;
234
235
        union wpa_event_data data;
235
 
        
 
236
        u8 *resp_ies = NULL;
 
237
 
236
238
        if ((left = recv(sock, buf, sizeof buf, 0)) < 0)
237
239
                return;
238
240
 
256
258
                wpa_printf(MSG_DEBUG, "BROADCOM: ASSOC MESSAGE (left: %d)",
257
259
                           left);
258
260
                if (left > 0) {
259
 
                        data.assoc_info.resp_ies = os_malloc(left);
260
 
                        if (data.assoc_info.resp_ies == NULL)
 
261
                        resp_ies = os_malloc(left);
 
262
                        if (resp_ies == NULL)
261
263
                                return;
262
 
                        os_memcpy(data.assoc_info.resp_ies,
263
 
                                  buf + WL_WPA_HEADER_LEN, left);
 
264
                        os_memcpy(resp_ies, buf + WL_WPA_HEADER_LEN, left);
 
265
                        data.assoc_info.resp_ies = resp_ies;
264
266
                        data.assoc_info.resp_ies_len = left;
265
 
                        wpa_hexdump(MSG_MSGDUMP, "BROADCOM: copying %d bytes "
266
 
                                    "into resp_ies",
267
 
                                    data.assoc_info.resp_ies, left);
268
267
                }
269
 
                /* data.assoc_info.req_ies = NULL; */
270
 
                /* data.assoc_info.req_ies_len = 0; */
271
268
 
272
 
                wpa_supplicant_event(ctx, EVENT_ASSOCINFO, &data);
273
 
                wpa_supplicant_event(ctx, EVENT_ASSOC, NULL);
 
269
                wpa_supplicant_event(ctx, EVENT_ASSOC, &data);
 
270
                os_free(resp_ies);
274
271
                break;
275
272
        case WLC_DISASSOC_MSG:
276
273
                wpa_printf(MSG_DEBUG, "BROADCOM: DISASSOC MESSAGE");
291
288
                           wwh->type);
292
289
                break;
293
290
        }
294
 
        os_free(data.assoc_info.resp_ies);
295
291
}       
296
292
 
297
293
static void * wpa_driver_broadcom_init(void *ctx, const char *ifname)
348
344
        eloop_register_read_sock(s, wpa_driver_broadcom_event_receive, ctx,
349
345
                                 NULL);
350
346
        drv->event_sock = s;
 
347
        wpa_driver_broadcom_set_wpa(drv, 1);
351
348
 
352
349
        return drv;
353
350
}
355
352
static void wpa_driver_broadcom_deinit(void *priv)
356
353
{
357
354
        struct wpa_driver_broadcom_data *drv = priv;
 
355
        wpa_driver_broadcom_set_wpa(drv, 0);
358
356
        eloop_cancel_timeout(wpa_driver_broadcom_scan_timeout, drv, drv->ctx);
359
357
        eloop_unregister_read_sock(drv->event_sock);
360
358
        close(drv->event_sock);
379
377
{
380
378
        struct wpa_driver_broadcom_data *drv = priv;
381
379
        /* SET_EAP_RESTRICT, SET_WEP_RESTRICT */
382
 
        int restrict = (enabled ? 1 : 0);
 
380
        int _restrict = (enabled ? 1 : 0);
383
381
        
384
382
        if (broadcom_ioctl(drv, WLC_SET_WEP_RESTRICT, 
385
 
                           &restrict, sizeof(restrict)) < 0 ||
 
383
                           &_restrict, sizeof(_restrict)) < 0 ||
386
384
            broadcom_ioctl(drv, WLC_SET_EAP_RESTRICT,
387
 
                           &restrict, sizeof(restrict)) < 0)
 
385
                           &_restrict, sizeof(_restrict)) < 0)
388
386
                return -1;
389
387
 
390
388
        return 0;
397
395
        wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
398
396
}
399
397
 
400
 
static int wpa_driver_broadcom_scan(void *priv, const u8 *ssid,
401
 
                                    size_t ssid_len)
 
398
static int wpa_driver_broadcom_scan(void *priv,
 
399
                                    struct wpa_driver_scan_params *params)
402
400
{
403
401
        struct wpa_driver_broadcom_data *drv = priv;
404
402
        wlc_ssid_t wst = { 0, "" };
 
403
        const u8 *ssid = params->ssids[0].ssid;
 
404
        size_t ssid_len = params->ssids[0].ssid_len;
405
405
 
406
406
        if (ssid && ssid_len > 0 && ssid_len <= sizeof(wst.SSID)) {
407
407
                wst.SSID_len = ssid_len;
431
431
        /* u16 version; */
432
432
} __attribute__ ((packed));
433
433
 
434
 
static int
435
 
wpa_driver_broadcom_get_scan_results(void *priv,
436
 
                                     struct wpa_scan_result *results,
437
 
                                     size_t max_size)
 
434
static struct wpa_scan_results *
 
435
wpa_driver_broadcom_get_scan_results(void *priv)
438
436
{
439
437
        struct wpa_driver_broadcom_data *drv = priv;
440
438
        char *buf;
441
439
        wl_scan_results_t *wsr;
442
440
        wl_bss_info_t *wbi;
443
441
        size_t ap_num;
 
442
        struct wpa_scan_results *res;
444
443
 
445
444
        buf = os_malloc(WLC_IOCTL_MAXLEN);
446
445
        if (buf == NULL)
447
 
                return -1;
 
446
                return NULL;
448
447
 
449
448
        wsr = (wl_scan_results_t *) buf;
450
449
 
454
453
 
455
454
        if (broadcom_ioctl(drv, WLC_SCAN_RESULTS, buf, WLC_IOCTL_MAXLEN) < 0) {
456
455
                os_free(buf);
457
 
                return -1;
458
 
        }
459
 
 
460
 
        os_memset(results, 0, max_size * sizeof(struct wpa_scan_result));
 
456
                return NULL;
 
457
        }
 
458
 
 
459
        res = os_zalloc(sizeof(*res));
 
460
        if (res == NULL) {
 
461
                os_free(buf);
 
462
                return NULL;
 
463
        }
 
464
 
 
465
        res->res = os_zalloc(wsr->count * sizeof(struct wpa_scan_res *));
 
466
        if (res->res == NULL) {
 
467
                os_free(res);
 
468
                os_free(buf);
 
469
                return NULL;
 
470
        }
461
471
 
462
472
        for (ap_num = 0, wbi = wsr->bss_info; ap_num < wsr->count; ++ap_num) {
463
 
                int left;
464
 
                struct bss_ie_hdr *ie;
465
 
                
466
 
                os_memcpy(results[ap_num].bssid, &wbi->BSSID, ETH_ALEN);
467
 
                os_memcpy(results[ap_num].ssid, wbi->SSID, wbi->SSID_len);
468
 
                results[ap_num].ssid_len = wbi->SSID_len;
469
 
                results[ap_num].freq = frequency_list[wbi->channel - 1];
 
473
                struct wpa_scan_res *r;
 
474
                r = os_malloc(sizeof(*r) + wbi->ie_length);
 
475
                if (r == NULL)
 
476
                        break;
 
477
                res->res[res->num++] = r;
 
478
 
 
479
                os_memcpy(r->bssid, &wbi->BSSID, ETH_ALEN);
 
480
                r->freq = frequency_list[wbi->channel - 1];
470
481
                /* get ie's */
471
 
                wpa_hexdump(MSG_MSGDUMP, "BROADCOM: AP IEs",
472
 
                            (u8 *) wbi + sizeof(*wbi), wbi->ie_length);
473
 
                ie = (struct bss_ie_hdr *) ((u8 *) wbi + sizeof(*wbi));
474
 
                for (left = wbi->ie_length; left > 0;
475
 
                     left -= (ie->len + 2), ie = (struct bss_ie_hdr *)
476
 
                             ((u8 *) ie + 2 + ie->len)) {
477
 
                        wpa_printf(MSG_MSGDUMP, "BROADCOM: IE: id:%x, len:%d",
478
 
                                   ie->elem_id, ie->len);
479
 
                        if (ie->len >= 3) 
480
 
                                wpa_printf(MSG_MSGDUMP,
481
 
                                           "BROADCOM: oui:%02x%02x%02x",
482
 
                                           ie->oui[0], ie->oui[1], ie->oui[2]);
483
 
                        if (ie->elem_id != 0xdd ||
484
 
                            ie->len < 6 ||
485
 
                            os_memcmp(ie->oui, WPA_OUI, 3) != 0)
486
 
                                continue;
487
 
                        os_memcpy(results[ap_num].wpa_ie, ie, ie->len + 2);
488
 
                        results[ap_num].wpa_ie_len = ie->len + 2;
489
 
                        break;
490
 
                }
 
482
                os_memcpy(r + 1, wbi + 1, wbi->ie_length);
 
483
                r->ie_len = wbi->ie_length;
491
484
 
492
485
                wbi = (wl_bss_info_t *) ((u8 *) wbi + wbi->length);
493
486
        }
497
490
                   wsr->buflen, (unsigned long) ap_num);
498
491
        
499
492
        os_free(buf);
500
 
        return ap_num;
501
 
}
 
493
        return res;
 
494
        }
502
495
 
503
496
static int wpa_driver_broadcom_deauthenticate(void *priv, const u8 *addr,
504
497
                                              int reason_code)
516
509
                                            int reason_code)
517
510
{
518
511
        struct wpa_driver_broadcom_data *drv = priv;
519
 
        return broadcom_ioctl(drv, WLC_DISASSOC, 0, 0);
 
512
        return broadcom_ioctl(drv, WLC_DISASSOC, NULL, 0);
520
513
}
521
514
 
522
515
static int
530
523
        int wsec = 4;
531
524
        int dummy;
532
525
        int wpa_auth;
533
 
        
 
526
        int ret;
 
527
 
 
528
        ret = wpa_driver_broadcom_set_drop_unencrypted(
 
529
                drv, params->drop_unencrypted);
 
530
 
534
531
        s.SSID_len = params->ssid_len;
535
532
        os_memcpy(s.SSID, params->ssid, params->ssid_len);
536
533
 
582
579
            broadcom_ioctl(drv, WLC_SET_SSID, &s, sizeof(s)) < 0)
583
580
                return -1;
584
581
 
585
 
        return 0;
 
582
        return ret;
586
583
}
587
584
 
588
585
const struct wpa_driver_ops wpa_driver_broadcom_ops = {
590
587
        .desc = "Broadcom wl.o driver",
591
588
        .get_bssid = wpa_driver_broadcom_get_bssid,
592
589
        .get_ssid = wpa_driver_broadcom_get_ssid,
593
 
        .set_wpa = wpa_driver_broadcom_set_wpa,
594
590
        .set_key = wpa_driver_broadcom_set_key,
595
591
        .init = wpa_driver_broadcom_init,
596
592
        .deinit = wpa_driver_broadcom_deinit,
597
593
        .set_countermeasures = wpa_driver_broadcom_set_countermeasures,
598
 
        .set_drop_unencrypted = wpa_driver_broadcom_set_drop_unencrypted,
599
 
        .scan = wpa_driver_broadcom_scan,
600
 
        .get_scan_results = wpa_driver_broadcom_get_scan_results,
 
594
        .scan2 = wpa_driver_broadcom_scan,
 
595
        .get_scan_results2 = wpa_driver_broadcom_get_scan_results,
601
596
        .deauthenticate = wpa_driver_broadcom_deauthenticate,
602
597
        .disassociate = wpa_driver_broadcom_disassociate,
603
598
        .associate = wpa_driver_broadcom_associate,