driver_broadcom.c

WLAN无线网络管理的最新程序

		perror("socket");
		return NULL;
	}
	/* do it */
	os_strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
	if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
		perror(ifr.ifr_name);
		return NULL;
	}


	drv = os_zalloc(sizeof(*drv));
	if (drv == NULL)
		return NULL;
	drv->ctx = ctx;
	os_strncpy(drv->ifname, ifname, sizeof(drv->ifname));
	drv->ioctl_sock = s;

	s = socket(PF_PACKET, SOCK_RAW, ntohs(ETH_P_802_2));
	if (s < 0) {
		perror("socket(PF_PACKET, SOCK_RAW, ntohs(ETH_P_802_2))");
		close(drv->ioctl_sock);
		os_free(drv);
		return NULL;
	}

	os_memset(&ll, 0, sizeof(ll));
	ll.sll_family = AF_PACKET;
	ll.sll_protocol = ntohs(ETH_P_802_2);
	ll.sll_ifindex = ifr.ifr_ifindex;
	ll.sll_hatype = 0;
	ll.sll_pkttype = PACKET_HOST;
	ll.sll_halen = 0;

	if (bind(s, (struct sockaddr *) &ll, sizeof(ll)) < 0) {
		perror("bind(netlink)");
		close(s);
		close(drv->ioctl_sock);
		os_free(drv);
		return NULL;
	}

	eloop_register_read_sock(s, wpa_driver_broadcom_event_receive, ctx,
				 NULL);
	drv->event_sock = s;

	return drv;
}

static void wpa_driver_broadcom_deinit(void *priv)
{
	struct wpa_driver_broadcom_data *drv = priv;
	eloop_cancel_timeout(wpa_driver_broadcom_scan_timeout, drv, drv->ctx);
	eloop_unregister_read_sock(drv->event_sock);
	close(drv->event_sock);
	close(drv->ioctl_sock);
	os_free(drv);
}

static int wpa_driver_broadcom_set_countermeasures(void *priv,
						   int enabled)
{
#if 0
	struct wpa_driver_broadcom_data *drv = priv;
	/* FIX: ? */
	return broadcom_ioctl(drv, WLC_SET_TKIP_COUNTERMEASURES, &enabled,
			      sizeof(enabled));
#else
	return 0;
#endif
}

static int wpa_driver_broadcom_set_drop_unencrypted(void *priv, int enabled)
{
	struct wpa_driver_broadcom_data *drv = priv;
	/* SET_EAP_RESTRICT, SET_WEP_RESTRICT */
	int restrict = (enabled ? 1 : 0);
	
	if (broadcom_ioctl(drv, WLC_SET_WEP_RESTRICT, 
			   &restrict, sizeof(restrict)) < 0 ||
	    broadcom_ioctl(drv, WLC_SET_EAP_RESTRICT,
			   &restrict, sizeof(restrict)) < 0)
		return -1;

	return 0;
}

static void wpa_driver_broadcom_scan_timeout(void *eloop_ctx,
					     void *timeout_ctx)
{
	wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
	wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
}

static int wpa_driver_broadcom_scan(void *priv, const u8 *ssid,
				    size_t ssid_len)
{
	struct wpa_driver_broadcom_data *drv = priv;
	wlc_ssid_t wst = { 0, "" };

	if (ssid && ssid_len > 0 && ssid_len <= sizeof(wst.SSID)) {
		wst.SSID_len = ssid_len;
		os_memcpy(wst.SSID, ssid, ssid_len);
	}
	
	if (broadcom_ioctl(drv, WLC_SCAN, &wst, sizeof(wst)) < 0)
		return -1;

	eloop_cancel_timeout(wpa_driver_broadcom_scan_timeout, drv, drv->ctx);
	eloop_register_timeout(3, 0, wpa_driver_broadcom_scan_timeout, drv,
			       drv->ctx);
	return 0;
}


static const int frequency_list[] = { 
	2412, 2417, 2422, 2427, 2432, 2437, 2442,
	2447, 2452, 2457, 2462, 2467, 2472, 2484 
};

struct bss_ie_hdr {
	u8 elem_id;
	u8 len;
	u8 oui[3];
	/* u8 oui_type; */
	/* u16 version; */
} __attribute__ ((packed));

static int
wpa_driver_broadcom_get_scan_results(void *priv,
				     struct wpa_scan_result *results,
				     size_t max_size)
{
	struct wpa_driver_broadcom_data *drv = priv;
	char *buf;
	wl_scan_results_t *wsr = (wl_scan_results_t *) buf;
	wl_bss_info_t *wbi;
	size_t ap_num;

	buf = os_malloc(WLC_IOCTL_MAXLEN);
	if (buf == NULL)
		return -1;

	wsr = (wl_scan_results_t *) buf;

	wsr->buflen = WLC_IOCTL_MAXLEN - sizeof(wsr);
	wsr->version = 107;
	wsr->count = 0;

	if (broadcom_ioctl(drv, WLC_SCAN_RESULTS, buf, WLC_IOCTL_MAXLEN) < 0) {
		os_free(buf);
		return -1;
	}

	os_memset(results, 0, max_size * sizeof(struct wpa_scan_result));

	for (ap_num = 0, wbi = wsr->bss_info; ap_num < wsr->count; ++ap_num) {
		int left;
		struct bss_ie_hdr *ie;
		
		os_memcpy(results[ap_num].bssid, &wbi->BSSID, ETH_ALEN);
		os_memcpy(results[ap_num].ssid, wbi->SSID, wbi->SSID_len);
		results[ap_num].ssid_len = wbi->SSID_len;
		results[ap_num].freq = frequency_list[wbi->channel - 1];
		/* get ie's */
		wpa_hexdump(MSG_MSGDUMP, "BROADCOM: AP IEs",
			    (u8 *) wbi + sizeof(*wbi), wbi->ie_length);
		ie = (struct bss_ie_hdr *) ((u8 *) wbi + sizeof(*wbi));
		for (left = wbi->ie_length; left > 0;
		     left -= (ie->len + 2), ie = (struct bss_ie_hdr *)
			     ((u8 *) ie + 2 + ie->len)) {
			wpa_printf(MSG_MSGDUMP, "BROADCOM: IE: id:%x, len:%d",
				   ie->elem_id, ie->len);
			if (ie->len >= 3) 
				wpa_printf(MSG_MSGDUMP,
					   "BROADCOM: oui:%02x%02x%02x",
					   ie->oui[0], ie->oui[1], ie->oui[2]);
			if (ie->elem_id != 0xdd ||
			    ie->len < 6 ||
			    os_memcmp(ie->oui, WPA_OUI, 3) != 0)
				continue;
			os_memcpy(results[ap_num].wpa_ie, ie, ie->len + 2);
			results[ap_num].wpa_ie_len = ie->len + 2;
			break;
		}

		wbi = (wl_bss_info_t *) ((u8 *) wbi + wbi->length);
	}

	wpa_printf(MSG_MSGDUMP, "Received %d bytes of scan results (%d BSSes)",
		   wsr->buflen, ap_num);
	
	os_free(buf);
	return ap_num;
}

static int wpa_driver_broadcom_deauthenticate(void *priv, const u8 *addr,
					      int reason_code)
{
	struct wpa_driver_broadcom_data *drv = priv;
	wlc_deauth_t wdt;
	wdt.val = reason_code;
	os_memcpy(&wdt.ea, addr, sizeof wdt.ea);
	wdt.res = 0x7fff;
	return broadcom_ioctl(drv, WLC_DEAUTHENTICATE_WITH_REASON, &wdt,
			      sizeof(wdt));
}

static int wpa_driver_broadcom_disassociate(void *priv, const u8 *addr,
					    int reason_code)
{
	struct wpa_driver_broadcom_data *drv = priv;
	return broadcom_ioctl(drv, WLC_DISASSOC, 0, 0);
}

static int
wpa_driver_broadcom_associate(void *priv,
			      struct wpa_driver_associate_params *params)
{
	struct wpa_driver_broadcom_data *drv = priv;
	wlc_ssid_t s;
	int infra = 1;
	int auth = 0;
	int wsec = 4;
	int dummy;
	int wpa_auth;
	
	s.SSID_len = params->ssid_len;
	os_memcpy(s.SSID, params->ssid, params->ssid_len);

	switch (params->pairwise_suite) {
	case CIPHER_WEP40:
	case CIPHER_WEP104:
		wsec = 1;
		break;

	case CIPHER_TKIP:
		wsec = 2;
		break;

	case CIPHER_CCMP:
		wsec = 4;
		break;

	default:
		wsec = 0;
		break;
	}

	switch (params->key_mgmt_suite) {
	case KEY_MGMT_802_1X:
		wpa_auth = 1;
		break;

	case KEY_MGMT_PSK:
		wpa_auth = 2;
		break;

	default:
		wpa_auth = 255;
		break;
	}

	/* printf("broadcom_associate: %u %u %u\n", pairwise_suite,
	 * group_suite, key_mgmt_suite);
	 * broadcom_ioctl(ifname, WLC_GET_WSEC, &wsec, sizeof(wsec));
	 * wl join uses wlc_sec_wep here, not wlc_set_wsec */

	if (broadcom_ioctl(drv, WLC_SET_WSEC, &wsec, sizeof(wsec)) < 0 ||
	    broadcom_ioctl(drv, WLC_SET_WPA_AUTH, &wpa_auth,
			   sizeof(wpa_auth)) < 0 ||
	    broadcom_ioctl(drv, WLC_GET_WEP, &dummy, sizeof(dummy)) < 0 ||
	    broadcom_ioctl(drv, WLC_SET_INFRA, &infra, sizeof(infra)) < 0 ||
	    broadcom_ioctl(drv, WLC_SET_AUTH, &auth, sizeof(auth)) < 0 ||
	    broadcom_ioctl(drv, WLC_SET_WEP, &wsec, sizeof(wsec)) < 0 ||
	    broadcom_ioctl(drv, WLC_SET_SSID, &s, sizeof(s)) < 0)
		return -1;

	return 0;
}

const struct wpa_driver_ops wpa_driver_broadcom_ops = {
	.name = "broadcom",
	.desc = "Broadcom wl.o driver",
	.get_bssid = wpa_driver_broadcom_get_bssid,
	.get_ssid = wpa_driver_broadcom_get_ssid,
	.set_wpa = wpa_driver_broadcom_set_wpa,
	.set_key = wpa_driver_broadcom_set_key,
	.init = wpa_driver_broadcom_init,
	.deinit = wpa_driver_broadcom_deinit,
	.set_countermeasures = wpa_driver_broadcom_set_countermeasures,
	.set_drop_unencrypted = wpa_driver_broadcom_set_drop_unencrypted,
	.scan = wpa_driver_broadcom_scan,
	.get_scan_results = wpa_driver_broadcom_get_scan_results,
	.deauthenticate = wpa_driver_broadcom_deauthenticate,
	.disassociate = wpa_driver_broadcom_disassociate,
	.associate = wpa_driver_broadcom_associate,
};