staging: rtl8192e: Fix PREFER_ETHER_ADDR_COPY warnings (b57ceb19) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/staging/rtl8192e/rtl8192e/r8192E_dev.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -382,7 +382,7 @@ static void rtl8192_read_eeprom_info(struct net_device *dev)
	(u16 )(&dev->dev_addr[i]) = usValue;		(u16 )(&dev->dev_addr[i]) = usValue;
	}		}
	} else {		} else {
	memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);		ether_addr_copy(dev->dev_addr, bMac_Tmp_Addr);
	}		}

	RT_TRACE(COMP_INIT, "Permanent Address = %pM\n",		RT_TRACE(COMP_INIT, "Permanent Address = %pM\n",

drivers/staging/rtl8192e/rtl819x_BAProc.c

+7 −6

Original line number	Original line	Diff line number	Diff line
	@@ -18,6 +18,7 @@
	******************************************************************************/		******************************************************************************/
	#include <asm/byteorder.h>		#include <asm/byteorder.h>
	#include <asm/unaligned.h>		#include <asm/unaligned.h>
			#include <linux/etherdevice.h>
	#include "rtllib.h"		#include "rtllib.h"
	#include "rtl819x_BA.h"		#include "rtl819x_BA.h"

	@@ -103,10 +104,10 @@ static struct sk_buff rtllib_ADDBA(struct rtllib_device ieee, u8 *Dst,
	BAReq = (struct rtllib_hdr_3addr *)skb_put(skb,		BAReq = (struct rtllib_hdr_3addr *)skb_put(skb,
	sizeof(struct rtllib_hdr_3addr));		sizeof(struct rtllib_hdr_3addr));

	memcpy(BAReq->addr1, Dst, ETH_ALEN);		ether_addr_copy(BAReq->addr1, Dst);
	memcpy(BAReq->addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(BAReq->addr2, ieee->dev->dev_addr);

	memcpy(BAReq->addr3, ieee->current_network.bssid, ETH_ALEN);		ether_addr_copy(BAReq->addr3, ieee->current_network.bssid);
	BAReq->frame_ctl = cpu_to_le16(RTLLIB_STYPE_MANAGE_ACT);		BAReq->frame_ctl = cpu_to_le16(RTLLIB_STYPE_MANAGE_ACT);

	tag = (u8 *)skb_put(skb, 9);		tag = (u8 *)skb_put(skb, 9);
	@@ -167,9 +168,9 @@ static struct sk_buff rtllib_DELBA(struct rtllib_device ieee, u8 *dst,
	Delba = (struct rtllib_hdr_3addr *) skb_put(skb,		Delba = (struct rtllib_hdr_3addr *) skb_put(skb,
	sizeof(struct rtllib_hdr_3addr));		sizeof(struct rtllib_hdr_3addr));

	memcpy(Delba->addr1, dst, ETH_ALEN);		ether_addr_copy(Delba->addr1, dst);
	memcpy(Delba->addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(Delba->addr2, ieee->dev->dev_addr);
	memcpy(Delba->addr3, ieee->current_network.bssid, ETH_ALEN);		ether_addr_copy(Delba->addr3, ieee->current_network.bssid);
	Delba->frame_ctl = cpu_to_le16(RTLLIB_STYPE_MANAGE_ACT);		Delba->frame_ctl = cpu_to_le16(RTLLIB_STYPE_MANAGE_ACT);

	tag = (u8 *)skb_put(skb, 6);		tag = (u8 *)skb_put(skb, 6);

drivers/staging/rtl8192e/rtllib_crypt_tkip.c

+10 −9

Original line number	Original line	Diff line number	Diff line
	@@ -21,6 +21,7 @@
	#include <linux/crypto.h>		#include <linux/crypto.h>
	#include <linux/scatterlist.h>		#include <linux/scatterlist.h>
	#include <linux/crc32.h>		#include <linux/crc32.h>
			#include <linux/etherdevice.h>

	#include "rtllib.h"		#include "rtllib.h"

	@@ -533,20 +534,20 @@ static void michael_mic_hdr(struct sk_buff skb, u8 hdr)
	switch (le16_to_cpu(hdr11->frame_ctl) &		switch (le16_to_cpu(hdr11->frame_ctl) &
	(RTLLIB_FCTL_FROMDS \| RTLLIB_FCTL_TODS)) {		(RTLLIB_FCTL_FROMDS \| RTLLIB_FCTL_TODS)) {
	case RTLLIB_FCTL_TODS:		case RTLLIB_FCTL_TODS:
	memcpy(hdr, hdr11->addr3, ETH_ALEN); /* DA */		ether_addr_copy(hdr, hdr11->addr3); /* DA */
	memcpy(hdr + ETH_ALEN, hdr11->addr2, ETH_ALEN); /* SA */		ether_addr_copy(hdr + ETH_ALEN, hdr11->addr2); /* SA */
	break;		break;
	case RTLLIB_FCTL_FROMDS:		case RTLLIB_FCTL_FROMDS:
	memcpy(hdr, hdr11->addr1, ETH_ALEN); /* DA */		ether_addr_copy(hdr, hdr11->addr1); /* DA */
	memcpy(hdr + ETH_ALEN, hdr11->addr3, ETH_ALEN); /* SA */		ether_addr_copy(hdr + ETH_ALEN, hdr11->addr3); /* SA */
	break;		break;
	case RTLLIB_FCTL_FROMDS \| RTLLIB_FCTL_TODS:		case RTLLIB_FCTL_FROMDS \| RTLLIB_FCTL_TODS:
	memcpy(hdr, hdr11->addr3, ETH_ALEN); /* DA */		ether_addr_copy(hdr, hdr11->addr3); /* DA */
	memcpy(hdr + ETH_ALEN, hdr11->addr4, ETH_ALEN); /* SA */		ether_addr_copy(hdr + ETH_ALEN, hdr11->addr4); /* SA */
	break;		break;
	case 0:		case 0:
	memcpy(hdr, hdr11->addr1, ETH_ALEN); /* DA */		ether_addr_copy(hdr, hdr11->addr1); /* DA */
	memcpy(hdr + ETH_ALEN, hdr11->addr2, ETH_ALEN); /* SA */		ether_addr_copy(hdr + ETH_ALEN, hdr11->addr2); /* SA */
	break;		break;
	}		}

	@@ -599,7 +600,7 @@ static void rtllib_michael_mic_failure(struct net_device *dev,
	else		else
	ev.flags \|= IW_MICFAILURE_PAIRWISE;		ev.flags \|= IW_MICFAILURE_PAIRWISE;
	ev.src_addr.sa_family = ARPHRD_ETHER;		ev.src_addr.sa_family = ARPHRD_ETHER;
	memcpy(ev.src_addr.sa_data, hdr->addr2, ETH_ALEN);		ether_addr_copy(ev.src_addr.sa_data, hdr->addr2);
	memset(&wrqu, 0, sizeof(wrqu));		memset(&wrqu, 0, sizeof(wrqu));
	wrqu.data.length = sizeof(ev);		wrqu.data.length = sizeof(ev);
	wireless_send_event(dev, IWEVMICHAELMICFAILURE, &wrqu, (char *) &ev);		wireless_send_event(dev, IWEVMICHAELMICFAILURE, &wrqu, (char *) &ev);

drivers/staging/rtl8192e/rtllib_rx.c

+25 −21

Original line number	Original line	Diff line number	Diff line
	@@ -139,8 +139,8 @@ rtllib_frag_cache_get(struct rtllib_device *ieee,
	entry->seq = seq;		entry->seq = seq;
	entry->last_frag = frag;		entry->last_frag = frag;
	entry->skb = skb;		entry->skb = skb;
	memcpy(entry->src_addr, hdr->addr2, ETH_ALEN);		ether_addr_copy(entry->src_addr, hdr->addr2);
	memcpy(entry->dst_addr, hdr->addr1, ETH_ALEN);		ether_addr_copy(entry->dst_addr, hdr->addr1);
	} else {		} else {
	/* received a fragment of a frame for which the head fragment		/* received a fragment of a frame for which the head fragment
	* should have already been received		* should have already been received
	@@ -400,7 +400,7 @@ static int is_duplicate_packet(struct rtllib_device *ieee,
	if (!entry)		if (!entry)
	return 0;		return 0;

	memcpy(entry->mac, mac, ETH_ALEN);		ether_addr_copy(entry->mac, mac);
	entry->seq_num[tid] = seq;		entry->seq_num[tid] = seq;
	entry->frag_num[tid] = frag;		entry->frag_num[tid] = frag;
	entry->packet_time[tid] = jiffies;		entry->packet_time[tid] = jiffies;
	@@ -927,24 +927,24 @@ static void rtllib_rx_extract_addr(struct rtllib_device *ieee,

	switch (fc & (RTLLIB_FCTL_FROMDS \| RTLLIB_FCTL_TODS)) {		switch (fc & (RTLLIB_FCTL_FROMDS \| RTLLIB_FCTL_TODS)) {
	case RTLLIB_FCTL_FROMDS:		case RTLLIB_FCTL_FROMDS:
	memcpy(dst, hdr->addr1, ETH_ALEN);		ether_addr_copy(dst, hdr->addr1);
	memcpy(src, hdr->addr3, ETH_ALEN);		ether_addr_copy(src, hdr->addr3);
	memcpy(bssid, hdr->addr2, ETH_ALEN);		ether_addr_copy(bssid, hdr->addr2);
	break;		break;
	case RTLLIB_FCTL_TODS:		case RTLLIB_FCTL_TODS:
	memcpy(dst, hdr->addr3, ETH_ALEN);		ether_addr_copy(dst, hdr->addr3);
	memcpy(src, hdr->addr2, ETH_ALEN);		ether_addr_copy(src, hdr->addr2);
	memcpy(bssid, hdr->addr1, ETH_ALEN);		ether_addr_copy(bssid, hdr->addr1);
	break;		break;
	case RTLLIB_FCTL_FROMDS \| RTLLIB_FCTL_TODS:		case RTLLIB_FCTL_FROMDS \| RTLLIB_FCTL_TODS:
	memcpy(dst, hdr->addr3, ETH_ALEN);		ether_addr_copy(dst, hdr->addr3);
	memcpy(src, hdr->addr4, ETH_ALEN);		ether_addr_copy(src, hdr->addr4);
	memcpy(bssid, ieee->current_network.bssid, ETH_ALEN);		ether_addr_copy(bssid, ieee->current_network.bssid);
	break;		break;
	case 0:		case 0:
	memcpy(dst, hdr->addr1, ETH_ALEN);		ether_addr_copy(dst, hdr->addr1);
	memcpy(src, hdr->addr2, ETH_ALEN);		ether_addr_copy(src, hdr->addr2);
	memcpy(bssid, hdr->addr3, ETH_ALEN);		ether_addr_copy(bssid, hdr->addr3);
	break;		break;
	}		}
	}		}
	@@ -1218,15 +1218,19 @@ static void rtllib_rx_indicate_pkt_legacy(struct rtllib_device *ieee,
	* replace EtherType		* replace EtherType
	*/		*/
	skb_pull(sub_skb, SNAP_SIZE);		skb_pull(sub_skb, SNAP_SIZE);
	memcpy(skb_push(sub_skb, ETH_ALEN), src, ETH_ALEN);		ether_addr_copy(skb_push(sub_skb, ETH_ALEN),
	memcpy(skb_push(sub_skb, ETH_ALEN), dst, ETH_ALEN);		src);
			ether_addr_copy(skb_push(sub_skb, ETH_ALEN),
			dst);
	} else {		} else {
	u16 len;		u16 len;
	/* Leave Ethernet header part of hdr and full payload */		/* Leave Ethernet header part of hdr and full payload */
	len = sub_skb->len;		len = sub_skb->len;
	memcpy(skb_push(sub_skb, 2), &len, 2);		memcpy(skb_push(sub_skb, 2), &len, 2);
	memcpy(skb_push(sub_skb, ETH_ALEN), src, ETH_ALEN);		ether_addr_copy(skb_push(sub_skb, ETH_ALEN),
	memcpy(skb_push(sub_skb, ETH_ALEN), dst, ETH_ALEN);		src);
			ether_addr_copy(skb_push(sub_skb, ETH_ALEN),
			dst);
	}		}

	ieee->stats.rx_packets++;		ieee->stats.rx_packets++;
	@@ -2050,7 +2054,7 @@ int rtllib_parse_info_param(struct rtllib_device *ieee,
	if (network->MBssidMask != 0) {		if (network->MBssidMask != 0) {
	network->bMBssidValid = true;		network->bMBssidValid = true;
	network->MBssidMask = 0xff << (network->MBssidMask);		network->MBssidMask = 0xff << (network->MBssidMask);
	memcpy(network->MBssid, network->bssid, ETH_ALEN);		ether_addr_copy(network->MBssid, network->bssid);
	network->MBssid[5] &= network->MBssidMask;		network->MBssid[5] &= network->MBssidMask;
	} else {		} else {
	network->bMBssidValid = false;		network->bMBssidValid = false;
	@@ -2210,7 +2214,7 @@ static inline int rtllib_network_init(
	memset(&network->qos_data, 0, sizeof(struct rtllib_qos_data));		memset(&network->qos_data, 0, sizeof(struct rtllib_qos_data));

	/* Pull out fixed field data */		/* Pull out fixed field data */
	memcpy(network->bssid, beacon->header.addr3, ETH_ALEN);		ether_addr_copy(network->bssid, beacon->header.addr3);
	network->capability = le16_to_cpu(beacon->capability);		network->capability = le16_to_cpu(beacon->capability);
	network->last_scanned = jiffies;		network->last_scanned = jiffies;
	network->time_stamp[0] = beacon->time_stamp[0];		network->time_stamp[0] = beacon->time_stamp[0];

drivers/staging/rtl8192e/rtllib_softmac.c

+32 −32

Original line number	Original line	Diff line number	Diff line
	@@ -372,7 +372,7 @@ static inline struct sk_buff rtllib_probe_req(struct rtllib_device ieee)
	req->header.duration_id = 0;		req->header.duration_id = 0;

	memset(req->header.addr1, 0xff, ETH_ALEN);		memset(req->header.addr1, 0xff, ETH_ALEN);
	memcpy(req->header.addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(req->header.addr2, ieee->dev->dev_addr);
	memset(req->header.addr3, 0xff, ETH_ALEN);		memset(req->header.addr3, 0xff, ETH_ALEN);

	tag = (u8 *) skb_put(skb, len + 2 + rate_len);		tag = (u8 *) skb_put(skb, len + 2 + rate_len);
	@@ -815,9 +815,9 @@ inline struct sk_buff rtllib_authentication_req(struct rtllib_network beacon,
	auth->header.frame_ctl \|= cpu_to_le16(RTLLIB_FCTL_WEP);		auth->header.frame_ctl \|= cpu_to_le16(RTLLIB_FCTL_WEP);

	auth->header.duration_id = cpu_to_le16(0x013a);		auth->header.duration_id = cpu_to_le16(0x013a);
	memcpy(auth->header.addr1, beacon->bssid, ETH_ALEN);		ether_addr_copy(auth->header.addr1, beacon->bssid);
	memcpy(auth->header.addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(auth->header.addr2, ieee->dev->dev_addr);
	memcpy(auth->header.addr3, beacon->bssid, ETH_ALEN);		ether_addr_copy(auth->header.addr3, beacon->bssid);
	if (ieee->auth_mode == 0)		if (ieee->auth_mode == 0)
	auth->algorithm = WLAN_AUTH_OPEN;		auth->algorithm = WLAN_AUTH_OPEN;
	else if (ieee->auth_mode == 1)		else if (ieee->auth_mode == 1)
	@@ -909,9 +909,9 @@ static struct sk_buff rtllib_probe_resp(struct rtllib_device ieee,

	beacon_buf = (struct rtllib_probe_response *) skb_put(skb,		beacon_buf = (struct rtllib_probe_response *) skb_put(skb,
	(beacon_size - ieee->tx_headroom));		(beacon_size - ieee->tx_headroom));
	memcpy(beacon_buf->header.addr1, dest, ETH_ALEN);		ether_addr_copy(beacon_buf->header.addr1, dest);
	memcpy(beacon_buf->header.addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(beacon_buf->header.addr2, ieee->dev->dev_addr);
	memcpy(beacon_buf->header.addr3, ieee->current_network.bssid, ETH_ALEN);		ether_addr_copy(beacon_buf->header.addr3, ieee->current_network.bssid);

	beacon_buf->header.duration_id = 0;		beacon_buf->header.duration_id = 0;
	beacon_buf->beacon_interval =		beacon_buf->beacon_interval =
	@@ -1006,9 +1006,9 @@ static struct sk_buff rtllib_assoc_resp(struct rtllib_device ieee, u8 *dest)
	skb_put(skb, sizeof(struct rtllib_assoc_response_frame));		skb_put(skb, sizeof(struct rtllib_assoc_response_frame));

	assoc->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_ASSOC_RESP);		assoc->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_ASSOC_RESP);
	memcpy(assoc->header.addr1, dest, ETH_ALEN);		ether_addr_copy(assoc->header.addr1, dest);
	memcpy(assoc->header.addr3, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(assoc->header.addr3, ieee->dev->dev_addr);
	memcpy(assoc->header.addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(assoc->header.addr2, ieee->dev->dev_addr);
	assoc->capability = cpu_to_le16(ieee->iw_mode == IW_MODE_MASTER ?		assoc->capability = cpu_to_le16(ieee->iw_mode == IW_MODE_MASTER ?
	WLAN_CAPABILITY_ESS : WLAN_CAPABILITY_IBSS);		WLAN_CAPABILITY_ESS : WLAN_CAPABILITY_IBSS);

	@@ -1063,9 +1063,9 @@ static struct sk_buff rtllib_auth_resp(struct rtllib_device ieee, int status,
	auth->transaction = cpu_to_le16(2);		auth->transaction = cpu_to_le16(2);
	auth->algorithm = cpu_to_le16(WLAN_AUTH_OPEN);		auth->algorithm = cpu_to_le16(WLAN_AUTH_OPEN);

	memcpy(auth->header.addr3, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(auth->header.addr3, ieee->dev->dev_addr);
	memcpy(auth->header.addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(auth->header.addr2, ieee->dev->dev_addr);
	memcpy(auth->header.addr1, dest, ETH_ALEN);		ether_addr_copy(auth->header.addr1, dest);
	auth->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_AUTH);		auth->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_AUTH);
	return skb;		return skb;

	@@ -1086,9 +1086,9 @@ static struct sk_buff rtllib_null_func(struct rtllib_device ieee, short pwr)
	hdr = (struct rtllib_hdr_3addr *)skb_put(skb,		hdr = (struct rtllib_hdr_3addr *)skb_put(skb,
	sizeof(struct rtllib_hdr_3addr));		sizeof(struct rtllib_hdr_3addr));

	memcpy(hdr->addr1, ieee->current_network.bssid, ETH_ALEN);		ether_addr_copy(hdr->addr1, ieee->current_network.bssid);
	memcpy(hdr->addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(hdr->addr2, ieee->dev->dev_addr);
	memcpy(hdr->addr3, ieee->current_network.bssid, ETH_ALEN);		ether_addr_copy(hdr->addr3, ieee->current_network.bssid);

	hdr->frame_ctl = cpu_to_le16(RTLLIB_FTYPE_DATA \|		hdr->frame_ctl = cpu_to_le16(RTLLIB_FTYPE_DATA \|
	RTLLIB_STYPE_NULLFUNC \| RTLLIB_FCTL_TODS \|		RTLLIB_STYPE_NULLFUNC \| RTLLIB_FCTL_TODS \|
	@@ -1113,8 +1113,8 @@ static struct sk_buff rtllib_pspoll_func(struct rtllib_device ieee)
	hdr = (struct rtllib_pspoll_hdr *)skb_put(skb,		hdr = (struct rtllib_pspoll_hdr *)skb_put(skb,
	sizeof(struct rtllib_pspoll_hdr));		sizeof(struct rtllib_pspoll_hdr));

	memcpy(hdr->bssid, ieee->current_network.bssid, ETH_ALEN);		ether_addr_copy(hdr->bssid, ieee->current_network.bssid);
	memcpy(hdr->ta, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(hdr->ta, ieee->dev->dev_addr);

	hdr->aid = cpu_to_le16(ieee->assoc_id \| 0xc000);		hdr->aid = cpu_to_le16(ieee->assoc_id \| 0xc000);
	hdr->frame_ctl = cpu_to_le16(RTLLIB_FTYPE_CTL \| RTLLIB_STYPE_PSPOLL \|		hdr->frame_ctl = cpu_to_le16(RTLLIB_FTYPE_CTL \| RTLLIB_STYPE_PSPOLL \|
	@@ -1266,11 +1266,11 @@ inline struct sk_buff rtllib_association_req(struct rtllib_network beacon,

	hdr->header.frame_ctl = RTLLIB_STYPE_ASSOC_REQ;		hdr->header.frame_ctl = RTLLIB_STYPE_ASSOC_REQ;
	hdr->header.duration_id = cpu_to_le16(37);		hdr->header.duration_id = cpu_to_le16(37);
	memcpy(hdr->header.addr1, beacon->bssid, ETH_ALEN);		ether_addr_copy(hdr->header.addr1, beacon->bssid);
	memcpy(hdr->header.addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(hdr->header.addr2, ieee->dev->dev_addr);
	memcpy(hdr->header.addr3, beacon->bssid, ETH_ALEN);		ether_addr_copy(hdr->header.addr3, beacon->bssid);

	memcpy(ieee->ap_mac_addr, beacon->bssid, ETH_ALEN);		ether_addr_copy(ieee->ap_mac_addr, beacon->bssid);

	hdr->capability = cpu_to_le16(WLAN_CAPABILITY_ESS);		hdr->capability = cpu_to_le16(WLAN_CAPABILITY_ESS);
	if (beacon->capability & WLAN_CAPABILITY_PRIVACY)		if (beacon->capability & WLAN_CAPABILITY_PRIVACY)
	@@ -1830,7 +1830,7 @@ static int auth_rq_parse(struct sk_buff skb, u8 dest)
	}		}
	a = (struct rtllib_authentication *) skb->data;		a = (struct rtllib_authentication *) skb->data;

	memcpy(dest, a->header.addr2, ETH_ALEN);		ether_addr_copy(dest, a->header.addr2);

	if (le16_to_cpu(a->algorithm) != WLAN_AUTH_OPEN)		if (le16_to_cpu(a->algorithm) != WLAN_AUTH_OPEN)
	return WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG;		return WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG;
	@@ -1858,7 +1858,7 @@ static short probe_rq_parse(struct rtllib_device ieee, struct sk_buff skb,
	if (bssid_match)		if (bssid_match)
	return -1;		return -1;

	memcpy(src, header->addr2, ETH_ALEN);		ether_addr_copy(src, header->addr2);

	skbend = (u8 *)skb->data + skb->len;		skbend = (u8 *)skb->data + skb->len;

	@@ -1897,7 +1897,7 @@ static int assoc_rq_parse(struct sk_buff skb, u8 dest)

	a = (struct rtllib_assoc_request_frame *) skb->data;		a = (struct rtllib_assoc_request_frame *) skb->data;

	memcpy(dest, a->header.addr2, ETH_ALEN);		ether_addr_copy(dest, a->header.addr2);

	return 0;		return 0;
	}		}
	@@ -2652,7 +2652,7 @@ void rtllib_start_master_bss(struct rtllib_device *ieee)
	ieee->ssid_set = 1;		ieee->ssid_set = 1;
	}		}

	memcpy(ieee->current_network.bssid, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(ieee->current_network.bssid, ieee->dev->dev_addr);

	ieee->set_chan(ieee->dev, ieee->current_network.channel);		ieee->set_chan(ieee->dev, ieee->current_network.channel);
	ieee->state = RTLLIB_LINKED;		ieee->state = RTLLIB_LINKED;
	@@ -3519,9 +3519,9 @@ inline struct sk_buff rtllib_disauth_skb(struct rtllib_network beacon,
	disauth->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_DEAUTH);		disauth->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_DEAUTH);
	disauth->header.duration_id = 0;		disauth->header.duration_id = 0;

	memcpy(disauth->header.addr1, beacon->bssid, ETH_ALEN);		ether_addr_copy(disauth->header.addr1, beacon->bssid);
	memcpy(disauth->header.addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(disauth->header.addr2, ieee->dev->dev_addr);
	memcpy(disauth->header.addr3, beacon->bssid, ETH_ALEN);		ether_addr_copy(disauth->header.addr3, beacon->bssid);

	disauth->reason = cpu_to_le16(asRsn);		disauth->reason = cpu_to_le16(asRsn);
	return skb;		return skb;
	@@ -3546,9 +3546,9 @@ inline struct sk_buff rtllib_disassociate_skb(struct rtllib_network beacon,
	disass->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_DISASSOC);		disass->header.frame_ctl = cpu_to_le16(RTLLIB_STYPE_DISASSOC);
	disass->header.duration_id = 0;		disass->header.duration_id = 0;

	memcpy(disass->header.addr1, beacon->bssid, ETH_ALEN);		ether_addr_copy(disass->header.addr1, beacon->bssid);
	memcpy(disass->header.addr2, ieee->dev->dev_addr, ETH_ALEN);		ether_addr_copy(disass->header.addr2, ieee->dev->dev_addr);
	memcpy(disass->header.addr3, beacon->bssid, ETH_ALEN);		ether_addr_copy(disass->header.addr3, beacon->bssid);

	disass->reason = cpu_to_le16(asRsn);		disass->reason = cpu_to_le16(asRsn);
	return skb;		return skb;