← Back to branch summary

~ubuntu-branches/ubuntu/feisty/wpasupplicant/feisty

« back to all changes in this revision

Viewing changes to driver_broadcom.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2007-04-01 10:53:37 UTC
  • Revision ID: james.westby@ubuntu.com-20070401105337-3dd89n3g8ecdhjsl
Tags: 0.5.7-0ubuntu2
https://launchpad.net/bugs/98895
https://launchpad.net/bugs/98925
Apply patch from upstream after private email discussion:
http://w1.fi/gitweb/gitweb.cgi?p=hostap.git;a=commitdiff;h=33673d3f43da6f5ec0f0aa5a8245a1617b6eb2fd#patch1
Fixes LP: #98895, #98925

Show diffs side-by-side

added added

removed removed

Lines of Context:
driver_broadcom.c
75
75
} wlc_deauth_t;
76
76
 
77
77
 
78
 
static void wpa_driver_broadcom_scan_timeout(void *eloop_ctx,
79
 
                                             void *timeout_ctx);
80
 
 
81
78
static int broadcom_ioctl(struct wpa_driver_broadcom_data *drv, int cmd,
82
79
                          void *buf, int len)
83
80
{
92
89
        ioc.cmd = cmd;
93
90
        ioc.buf = buf;
94
91
        ioc.len = len;
95
 
        os_strncpy(ifr.ifr_name, drv->ifname, IFNAMSIZ);
 
92
        strncpy(ifr.ifr_name, drv->ifname, IFNAMSIZ);
96
93
        ifr.ifr_data = (caddr_t) &ioc;
97
94
        if ((ret = ioctl(drv->ioctl_sock, SIOCDEVPRIVATE, &ifr)) < 0) {
98
95
                if (cmd != WLC_GET_MAGIC)
110
107
        if (broadcom_ioctl(drv, WLC_GET_BSSID, bssid, ETH_ALEN) == 0)
111
108
                return 0;
112
109
        
113
 
        os_memset(bssid, 0, ETH_ALEN);
 
110
        memset(bssid, 0, ETH_ALEN);
114
111
        return -1;
115
112
}
116
113
 
122
119
        if (broadcom_ioctl(drv, WLC_GET_SSID, &s, sizeof(s)) == -1)
123
120
                return -1;
124
121
 
125
 
        os_memcpy(ssid, s.SSID, s.SSID_len);
 
122
        memcpy(ssid, s.SSID, s.SSID_len);
126
123
        return s.SSID_len;
127
124
}
128
125
 
132
129
        unsigned int wauth, wsec;
133
130
        struct ether_addr ea;
134
131
 
135
 
        os_memset(&ea, enable ? 0xff : 0, sizeof(ea));
 
132
        memset(&ea, enable ? 0xff : 0, sizeof(ea));
136
133
        if (broadcom_ioctl(drv, WLC_GET_WPA_AUTH, &wauth, sizeof(wauth)) ==
137
134
            -1 ||
138
135
            broadcom_ioctl(drv, WLC_GET_WSEC, &wsec, sizeof(wsec)) == -1)
166
163
        int ret;
167
164
        wsec_key_t wkt;
168
165
 
169
 
        os_memset(&wkt, 0, sizeof wkt);
 
166
        memset(&wkt, 0, sizeof wkt);
170
167
        wpa_printf(MSG_MSGDUMP, "BROADCOM: SET %sKEY[%d] alg=%d",
171
168
                   set_tx ? "PRIMARY " : "", key_idx, alg);
172
169
        if (key && key_len > 0)
200
197
        wkt.index = key_idx;
201
198
        wkt.len = key_len;
202
199
        if (key && key_len > 0) {
203
 
                os_memcpy(wkt.data, key, key_len);
 
200
                memcpy(wkt.data, key, key_len);
204
201
                if (key_len == 32) {
205
202
                        /* hack hack hack XXX */
206
 
                        os_memcpy(&wkt.data[16], &key[24], 8);
207
 
                        os_memcpy(&wkt.data[24], &key[16], 8);
 
203
                        memcpy(&wkt.data[16], &key[24], 8);
 
204
                        memcpy(&wkt.data[24], &key[16], 8);
208
205
                }
209
206
        }
210
207
        /* wkt.algo = CRYPTO_ALGO_...; */
211
208
        wkt.flags = set_tx ? 0 : WSEC_PRIMARY_KEY;
212
209
        if (addr && set_tx)
213
 
                os_memcpy(&wkt.ea, addr, sizeof(wkt.ea));
 
210
                memcpy(&wkt.ea, addr, sizeof(wkt.ea));
214
211
        ret = broadcom_ioctl(drv, WLC_SET_KEY, &wkt, sizeof(wkt));
215
212
        if (addr && set_tx) {
216
213
                /* FIX: magic number / error handling? */
228
225
        wl_wpa_header_t *wwh;
229
226
        union wpa_event_data data;
230
227
        
231
 
        if ((left = recv(sock, buf, sizeof buf, 0)) < 0)
 
228
        if ((left = recv(sock, buf, sizeof buf, 0)) == -1)
232
229
                return;
233
230
 
234
231
        wpa_hexdump(MSG_DEBUG, "RECEIVE EVENT", buf, left);
235
232
 
236
 
        if ((size_t) left < sizeof(wl_wpa_header_t))
 
233
        if (left < sizeof(wl_wpa_header_t))
237
234
                return;
238
235
 
239
236
        wwh = (wl_wpa_header_t *) buf;
240
237
 
241
238
        if (wwh->snap.type != WL_WPA_ETHER_TYPE)
242
239
                return;
243
 
        if (os_memcmp(&wwh->snap, wl_wpa_snap_template, 6) != 0)
 
240
        if (memcmp(&wwh->snap, wl_wpa_snap_template, 6) != 0)
244
241
                return;
245
242
 
246
 
        os_memset(&data, 0, sizeof(data));
 
243
        memset(&data, 0, sizeof(data));
247
244
 
248
245
        switch (wwh->type) {
249
246
        case WLC_ASSOC_MSG:
251
248
                wpa_printf(MSG_DEBUG, "BROADCOM: ASSOC MESSAGE (left: %d)",
252
249
                           left);
253
250
                if (left > 0) {
254
 
                        data.assoc_info.resp_ies = os_malloc(left);
 
251
                        data.assoc_info.resp_ies = malloc(left);
255
252
                        if (data.assoc_info.resp_ies == NULL)
256
253
                                return;
257
 
                        os_memcpy(data.assoc_info.resp_ies,
258
 
                                  buf + WL_WPA_HEADER_LEN, left);
 
254
                        memcpy(data.assoc_info.resp_ies,
 
255
                               buf + WL_WPA_HEADER_LEN, left);
259
256
                        data.assoc_info.resp_ies_len = left;
260
257
                        wpa_hexdump(MSG_MSGDUMP, "BROADCOM: copying %d bytes "
261
258
                                    "into resp_ies",
286
283
                           wwh->type);
287
284
                break;
288
285
        }
289
 
        os_free(data.assoc_info.resp_ies);
 
286
        free(data.assoc_info.resp_ies);
290
287
}       
291
288
 
292
289
static void * wpa_driver_broadcom_init(void *ctx, const char *ifname)
302
299
                return NULL;
303
300
        }
304
301
        /* do it */
305
 
        os_strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
 
302
        strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
306
303
        if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
307
304
                perror(ifr.ifr_name);
308
305
                return NULL;
309
306
        }
310
307
 
311
308
 
312
 
        drv = os_zalloc(sizeof(*drv));
 
309
        drv = wpa_zalloc(sizeof(*drv));
313
310
        if (drv == NULL)
314
311
                return NULL;
315
312
        drv->ctx = ctx;
316
 
        os_strncpy(drv->ifname, ifname, sizeof(drv->ifname));
 
313
        strncpy(drv->ifname, ifname, sizeof(drv->ifname));
317
314
        drv->ioctl_sock = s;
318
315
 
319
316
        s = socket(PF_PACKET, SOCK_RAW, ntohs(ETH_P_802_2));
320
317
        if (s < 0) {
321
318
                perror("socket(PF_PACKET, SOCK_RAW, ntohs(ETH_P_802_2))");
322
319
                close(drv->ioctl_sock);
323
 
                os_free(drv);
 
320
                free(drv);
324
321
                return NULL;
325
322
        }
326
323
 
327
 
        os_memset(&ll, 0, sizeof(ll));
 
324
        memset(&ll, 0, sizeof(ll));
328
325
        ll.sll_family = AF_PACKET;
329
326
        ll.sll_protocol = ntohs(ETH_P_802_2);
330
327
        ll.sll_ifindex = ifr.ifr_ifindex;
336
333
                perror("bind(netlink)");
337
334
                close(s);
338
335
                close(drv->ioctl_sock);
339
 
                os_free(drv);
 
336
                free(drv);
340
337
                return NULL;
341
338
        }
342
339
 
350
347
static void wpa_driver_broadcom_deinit(void *priv)
351
348
{
352
349
        struct wpa_driver_broadcom_data *drv = priv;
353
 
        eloop_cancel_timeout(wpa_driver_broadcom_scan_timeout, drv, drv->ctx);
354
350
        eloop_unregister_read_sock(drv->event_sock);
355
351
        close(drv->event_sock);
356
352
        close(drv->ioctl_sock);
357
 
        os_free(drv);
 
353
        free(drv);
358
354
}
359
355
 
360
356
static int wpa_driver_broadcom_set_countermeasures(void *priv,
400
396
 
401
397
        if (ssid && ssid_len > 0 && ssid_len <= sizeof(wst.SSID)) {
402
398
                wst.SSID_len = ssid_len;
403
 
                os_memcpy(wst.SSID, ssid, ssid_len);
 
399
                memcpy(wst.SSID, ssid, ssid_len);
404
400
        }
405
401
        
406
402
        if (broadcom_ioctl(drv, WLC_SCAN, &wst, sizeof(wst)) < 0)
434
430
        char *buf;
435
431
        wl_scan_results_t *wsr = (wl_scan_results_t *) buf;
436
432
        wl_bss_info_t *wbi;
437
 
        size_t ap_num;
 
433
        int ap_num;
438
434
 
439
 
        buf = os_malloc(WLC_IOCTL_MAXLEN);
 
435
        buf = malloc(WLC_IOCTL_MAXLEN);
440
436
        if (buf == NULL)
441
437
                return -1;
442
438
 
447
443
        wsr->count = 0;
448
444
 
449
445
        if (broadcom_ioctl(drv, WLC_SCAN_RESULTS, buf, WLC_IOCTL_MAXLEN) < 0) {
450
 
                os_free(buf);
 
446
                free(buf);
451
447
                return -1;
452
448
        }
453
449
 
454
 
        os_memset(results, 0, max_size * sizeof(struct wpa_scan_result));
 
450
        memset(results, 0, max_size * sizeof(struct wpa_scan_result));
455
451
 
456
452
        for (ap_num = 0, wbi = wsr->bss_info; ap_num < wsr->count; ++ap_num) {
457
453
                int left;
458
454
                struct bss_ie_hdr *ie;
459
455
                
460
 
                os_memcpy(results[ap_num].bssid, &wbi->BSSID, ETH_ALEN);
461
 
                os_memcpy(results[ap_num].ssid, wbi->SSID, wbi->SSID_len);
 
456
                memcpy(results[ap_num].bssid, &wbi->BSSID, ETH_ALEN);
 
457
                memcpy(results[ap_num].ssid, wbi->SSID, wbi->SSID_len);
462
458
                results[ap_num].ssid_len = wbi->SSID_len;
463
459
                results[ap_num].freq = frequency_list[wbi->channel - 1];
464
460
                /* get ie's */
476
472
                                           ie->oui[0], ie->oui[1], ie->oui[2]);
477
473
                        if (ie->elem_id != 0xdd ||
478
474
                            ie->len < 6 ||
479
 
                            os_memcmp(ie->oui, WPA_OUI, 3) != 0)
 
475
                            memcmp(ie->oui, WPA_OUI, 3) != 0)
480
476
                                continue;
481
 
                        os_memcpy(results[ap_num].wpa_ie, ie, ie->len + 2);
 
477
                        memcpy(results[ap_num].wpa_ie, ie, ie->len + 2);
482
478
                        results[ap_num].wpa_ie_len = ie->len + 2;
483
479
                        break;
484
480
                }
489
485
        wpa_printf(MSG_MSGDUMP, "Received %d bytes of scan results (%d BSSes)",
490
486
                   wsr->buflen, ap_num);
491
487
        
492
 
        os_free(buf);
 
488
        free(buf);
493
489
        return ap_num;
494
490
}
495
491
 
499
495
        struct wpa_driver_broadcom_data *drv = priv;
500
496
        wlc_deauth_t wdt;
501
497
        wdt.val = reason_code;
502
 
        os_memcpy(&wdt.ea, addr, sizeof wdt.ea);
 
498
        memcpy(&wdt.ea, addr, sizeof wdt.ea);
503
499
        wdt.res = 0x7fff;
504
500
        return broadcom_ioctl(drv, WLC_DEAUTHENTICATE_WITH_REASON, &wdt,
505
501
                              sizeof(wdt));
525
521
        int wpa_auth;
526
522
        
527
523
        s.SSID_len = params->ssid_len;
528
 
        os_memcpy(s.SSID, params->ssid, params->ssid_len);
 
524
        memcpy(s.SSID, params->ssid, params->ssid_len);
529
525
 
530
526
        switch (params->pairwise_suite) {
531
527
        case CIPHER_WEP40: