自学教程：C++ wldev_iovar_setbuf函数代码示例

static intwl_android_set_pmk(struct net_device *dev, char *command, int total_len){	uchar pmk[33];	int error = 0;	char smbuf[WLC_IOCTL_SMLEN];#ifdef OKC_DEBUG	int i = 0;#endif	bzero(pmk, sizeof(pmk));	memcpy((char *)pmk, command + strlen("SET_PMK "), 32);	error = wldev_iovar_setbuf(dev, "okc_info_pmk", pmk, 32, smbuf, sizeof(smbuf), NULL);	if (error) {		DHD_ERROR(("Failed to set PMK for OKC, error = %d/n", error));	}#ifdef OKC_DEBUG	DHD_ERROR(("PMK is "));	for (i = 0; i < 32; i++)		DHD_ERROR(("%02X ", pmk[i]));	DHD_ERROR(("/n"));#endif	return error;}

int wldev_set_country(	struct net_device *dev, char *country_code, bool notify, bool user_enforced){#ifdef TEGRA_REGION_BASED_NVRAM	if (nv_dhd_set_nvram_params(country_code, dev)) {		WLDEV_ERROR(("nvram params changed for country code: %s: Reload f/w/n", country_code));		return 0;	} else		return -1;#else /* TEGRA_REGION_BASED_NVRAM */	int error = -1;	wl_country_t cspec = {{0}, 0, {0}};	scb_val_t scbval;	char smbuf[WLC_IOCTL_SMLEN];	if (!country_code)		return error;	bzero(&scbval, sizeof(scb_val_t));	error = wldev_iovar_getbuf(dev, "country", NULL, 0, &cspec, sizeof(cspec), NULL);	if (error < 0) {		WLDEV_ERROR(("%s: get country failed = %d/n", __FUNCTION__, error));		return error;	}	if ((error < 0) ||	    (strncmp(country_code, cspec.ccode, WLC_CNTRY_BUF_SZ) != 0)) {		if (user_enforced) {			bzero(&scbval, sizeof(scb_val_t));			error = wldev_ioctl(dev, WLC_DISASSOC, &scbval, sizeof(scb_val_t), true);			if (error < 0) {				WLDEV_ERROR(("%s: set country failed due to Disassoc error %d/n",					__FUNCTION__, error));				return error;			}		}		cspec.rev = -1;		memcpy(cspec.country_abbrev, country_code, WLC_CNTRY_BUF_SZ);		memcpy(cspec.ccode, country_code, WLC_CNTRY_BUF_SZ);		get_customized_country_code((char *)&cspec.country_abbrev, &cspec);		error = wldev_iovar_setbuf(dev, "country", &cspec, sizeof(cspec),			smbuf, sizeof(smbuf), NULL);		if (error < 0) {			WLDEV_ERROR(("%s: set country for %s as %s rev %d failed/n",				__FUNCTION__, country_code, cspec.ccode, cspec.rev));			return error;		}		dhd_bus_country_set(dev, &cspec, notify);		WLDEV_ERROR(("%s: set country for %s as %s rev %d/n",			__FUNCTION__, country_code, cspec.ccode, cspec.rev));	}	return 0;#endif}

int set_roamscan_channel_list(struct net_device *dev,	unsigned char n, unsigned char channels[], int ioctl_ver){	int i;	int error;	struct {		int n;		chanspec_t channels[20];	} channel_list;	char iobuf[200];	uint band, band2G, band5G, bw;	roamscan_mode = 1;	if (n > 20)		n = 20;#ifdef D11AC_IOTYPES	if (ioctl_ver == 1) {		/* legacy chanspec */		band2G = WL_LCHANSPEC_BAND_2G;		band5G = WL_LCHANSPEC_BAND_5G;		bw = WL_LCHANSPEC_BW_20 | WL_LCHANSPEC_CTL_SB_NONE;	} else {		band2G = WL_CHANSPEC_BAND_2G;		band5G = WL_CHANSPEC_BAND_5G;		bw = WL_CHANSPEC_BW_20;	}#else	band2G = WL_CHANSPEC_BAND_2G;	band5G = WL_CHANSPEC_BAND_5G;	bw = WL_CHANSPEC_BW_20 | WL_CHANSPEC_CTL_SB_NONE;#endif /* D11AC_IOTYPES */	for (i = 0; i < n; i++) {		chanspec_t chanspec;		if (channels[i] <= 14) {			chanspec = band2G | bw | channels[i];		} else {			chanspec = band5G | bw | channels[i];		}		roam_cache[i].chanspec = chanspec;		channel_list.channels[i] = chanspec;		WL_DBG(("%s: channel[%d] - [%02d] /n", __FUNCTION__, i, channels[i]));	}	n_roam_cache = n;	channel_list.n = n;	error = wldev_iovar_setbuf(dev, "roamscan_channels", &channel_list,		sizeof(channel_list), iobuf, sizeof(iobuf), NULL);	if (error) {		WL_ERROR(("Failed to set roamscan channels, error = %d/n", error));	}	return error;}

s32 wldev_iovar_setint(	struct net_device *dev, s8 *iovar, s32 val){	s8 iovar_buf[WLC_IOCTL_SMLEN];	val = htod32(val);	memset(iovar_buf, 0, sizeof(iovar_buf));	return wldev_iovar_setbuf(dev, iovar, &val, sizeof(val), iovar_buf,		sizeof(iovar_buf), NULL);}

voidwldev_set_scanabort(struct net_device *dev){	s8 iovar_buf[WLC_IOCTL_SMLEN];	int ret = 0;	memset(iovar_buf, 0, sizeof(iovar_buf));	ret = wldev_iovar_setbuf(dev, "scanabort", NULL, 0, iovar_buf,		sizeof(iovar_buf), NULL);	if (ret)		printf("%s failed ret = %d/n", __func__, ret);}

int wldev_set_country(	struct net_device *dev, char *country_code, bool notify, bool user_enforced, int revinfo){	int error = -1;	wl_country_t cspec = {{0}, 0, {0}};	scb_val_t scbval;	char smbuf[WLC_IOCTL_SMLEN];	if (!country_code)		return error;	bzero(&scbval, sizeof(scb_val_t));	error = wldev_iovar_getbuf(dev, "country", NULL, 0, &cspec, sizeof(cspec), NULL);	if (error < 0) {		WLDEV_ERROR(("%s: get country failed = %d/n", __FUNCTION__, error));		return error;	}	if ((error < 0) ||			dhd_force_country_change(dev) ||	    (strncmp(country_code, cspec.ccode, WLC_CNTRY_BUF_SZ) != 0)) {		if (user_enforced) {			bzero(&scbval, sizeof(scb_val_t));			error = wldev_ioctl(dev, WLC_DISASSOC, &scbval, sizeof(scb_val_t), true);			if (error < 0) {				WLDEV_ERROR(("%s: set country failed due to Disassoc error %d/n",					__FUNCTION__, error));				return error;			}		}		cspec.rev = revinfo;		memcpy(cspec.country_abbrev, country_code, WLC_CNTRY_BUF_SZ);		memcpy(cspec.ccode, country_code, WLC_CNTRY_BUF_SZ);		dhd_get_customized_country_code(dev, (char *)&cspec.country_abbrev, &cspec);		error = wldev_iovar_setbuf(dev, "country", &cspec, sizeof(cspec),			smbuf, sizeof(smbuf), NULL);		if (error < 0) {			WLDEV_ERROR(("%s: set country for %s as %s rev %d failed/n",				__FUNCTION__, country_code, cspec.ccode, cspec.rev));			return error;		}		dhd_bus_country_set(dev, &cspec, notify);		WLDEV_ERROR(("%s: set country for %s as %s rev %d/n",			__FUNCTION__, country_code, cspec.ccode, cspec.rev));	}	return 0;}

static int wldev_set_pktfilter_enable_by_id(struct net_device *dev, int pkt_id, int enable){	wl_pkt_filter_enable_t	enable_parm;	char smbuf[WLC_IOCTL_SMLEN];	int res;	/* enable or disable pkt filter, enable:1, disable:0 */	enable_parm.id = htod32(pkt_id);	enable_parm.enable = htod32(enable);	res = wldev_iovar_setbuf(dev, "pkt_filter_enable", &enable_parm, sizeof(enable_parm),		smbuf, sizeof(smbuf), NULL);	if (res < 0) {		WLDEV_ERROR(("%s: set pkt_filter_enable failed, error:%d/n", __FUNCTION__, res));		return res;	}		return 0;}

int set_roamscan_channel_list(struct net_device *dev,	unsigned char n, unsigned char channels[], int ioctl_ver){	int i;	int error;	channel_list_t channel_list;	char iobuf[WLC_IOCTL_SMLEN];	roamscan_mode = ROAMSCAN_MODE_WES;	if (n > MAX_CHANNEL_LIST)		n = MAX_CHANNEL_LIST;	for (i = 0; i < n; i++) {		chanspec_t chanspec;		if (channels[i] <= CH_MAX_2G_CHANNEL) {			chanspec = band2G | band_bw | channels[i];		} else {			chanspec = band5G | band_bw | channels[i];		}		roam_cache[i].chanspec = chanspec;		channel_list.channels[i] = chanspec;		WL_DBG(("channel[%d] - [%02d] /n", i, channels[i]));	}	n_roam_cache = n;	channel_list.n = n;	/* need to set ROAMSCAN_MODE_NORMAL to update roamscan_channels,	 * otherwise, it won't be updated	 */	wldev_iovar_setint(dev, "roamscan_mode", ROAMSCAN_MODE_NORMAL);	error = wldev_iovar_setbuf(dev, "roamscan_channels", &channel_list,		sizeof(channel_list), iobuf, sizeof(iobuf), NULL);	if (error) {		WL_DBG(("Failed to set roamscan channels, error = %d/n", error));	}	wldev_iovar_setint(dev, "roamscan_mode", ROAMSCAN_MODE_WES);	return error;}

int wldev_set_country(	struct net_device *dev, char *country_code){	int error = -1;	wl_country_t cspec = {{0}, 0, {0}};	scb_val_t scbval;	char smbuf[WLC_IOCTL_SMLEN];	if (!country_code)		return error;	error = wldev_iovar_getbuf(dev, "country", &cspec, sizeof(cspec),		smbuf, sizeof(smbuf), NULL);	if (error < 0)		AP6210_ERR("%s: get country failed = %d/n", __FUNCTION__, error);	if ((error < 0) ||	    (strncmp(country_code, smbuf, WLC_CNTRY_BUF_SZ) != 0)) {		bzero(&scbval, sizeof(scb_val_t));		error = wldev_ioctl(dev, WLC_DISASSOC, &scbval, sizeof(scb_val_t), true);		if (error < 0) {			AP6210_ERR("%s: set country failed due to Disassoc error %d/n",				__FUNCTION__, error);			return error;		}		cspec.rev = -1;		memcpy(cspec.country_abbrev, country_code, WLC_CNTRY_BUF_SZ);		memcpy(cspec.ccode, country_code, WLC_CNTRY_BUF_SZ);		get_customized_country_code((char *)&cspec.country_abbrev, &cspec);		error = wldev_iovar_setbuf(dev, "country", &cspec, sizeof(cspec),			smbuf, sizeof(smbuf), NULL);		if (error < 0) {			AP6210_ERR("%s: set country for %s as %s rev %d failed/n",				__FUNCTION__, country_code, cspec.ccode, cspec.rev);			return error;		}		dhd_bus_country_set(dev, &cspec);		AP6210_ERR("%s: set country for %s as %s rev %d/n",			__FUNCTION__, country_code, cspec.ccode, cspec.rev);	}	return 0;}

static int wl_android_set_cckm_krk(struct net_device *dev, char *command){	int error;	unsigned char key[16];	static char iovar_buf[WLC_IOCTL_MEDLEN];	WL_TRACE(("%s: wl_iw_set_cckm_krk/n", dev->name));	memset(iovar_buf, 0, sizeof(iovar_buf));	memcpy(key, command+strlen("set cckm_krk")+1, 16);	error = wldev_iovar_setbuf(dev, "cckm_krk", key, sizeof(key),		iovar_buf, WLC_IOCTL_MEDLEN, NULL);	if (unlikely(error))	{		WL_ERR((" cckm_krk set error (%d)/n", error));		return -1;	}	return 0;}

intwl_cfgnan_rtt_config_handler(struct net_device *ndev,	struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data){	wl_nan_ranging_config_t rtt_config;	s32 ret = BCME_OK;	/* proceed only if mandatory argument is present - channel */	if (!cmd_data->chanspec) {		WL_ERR((" mandatory argument is not present /n"));		return -EINVAL;	}	/*	 * command to test	 *	 * wl: wl proxd_nancfg 44/80 128 32 ff:ff:ff:ff:ff:ff 1	 *	 * wpa_cli: DRIVER NAN_RTT_CONFIG CHAN=44/80	 */	memset(&rtt_config, 0, sizeof(wl_nan_ranging_config_t));	rtt_config.chanspec = cmd_data->chanspec;	rtt_config.timeslot = 128;	rtt_config.duration = 32;	memcpy(&rtt_config.allow_mac, &ether_bcast, ETHER_ADDR_LEN);	rtt_config.flags = 1;	ret = wldev_iovar_setbuf(ndev, "proxd_nancfg", &rtt_config,		sizeof(wl_nan_ranging_config_t), cfg->ioctl_buf,		WLC_IOCTL_MEDLEN, NULL);	if (unlikely(ret)) {		WL_ERR((" nan rtt config failed, error = %d /n", ret));	} else {		WL_DBG((" nan rtt config successful /n"));	}	return ret;}

intwl_cfgnan_transmit_handler(struct net_device *ndev,	struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data){	wl_nan_ioc_t *nanioc = NULL;	void *pxtlv;	s32 ret = BCME_OK;	u16 start, end;	u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;	uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;	/*	 * proceed only if mandatory arguments are present - subscriber id,	 * publisher id, mac address	 */	if ((!cmd_data->sub_id) || (!cmd_data->pub_id) ||		ETHER_ISNULLADDR(&cmd_data->mac_addr.octet)) {		WL_ERR((" mandatory arguments are not present /n"));		return -EINVAL;	}	nanioc = kzalloc(nanioc_size, kflags);	if (!nanioc) {		WL_ERR((" memory allocation failed /n"));		return -ENOMEM;	}	/*	 * command to test	 *	 * wl: wl nan trasnmit <sub_id> <pub_id> <mac_addr> -info <hex_string>	 *	 * wpa_cli: DRIVER NAN_TRANSMIT SUB_ID=<sub_id> PUB_ID=<pub_id>	 *          MAC_ADDR=<mac_addr> SVC_INFO=<hex_string>	 */	/* nan transmit */	start = end = NAN_IOCTL_BUF_SIZE;	nanioc->version = htod16(WL_NAN_IOCTL_VERSION);	nanioc->id = htod16(WL_NAN_CMD_TRANSMIT);	pxtlv = nanioc->data;	ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_INSTANCE_ID,		sizeof(wl_nan_instance_id_t), &cmd_data->sub_id);	if (unlikely(ret)) {		goto fail;	}	ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_REQUESTOR_ID,		sizeof(wl_nan_instance_id_t), &cmd_data->pub_id);	if (unlikely(ret)) {		goto fail;	}	ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_MAC_ADDR,		ETHER_ADDR_LEN, &cmd_data->mac_addr.octet);	if (unlikely(ret)) {		goto fail;	}	if (cmd_data->svc_info.data && cmd_data->svc_info.dlen) {		WL_DBG((" optional svc_info present, pack it /n"));		ret = bcm_pack_xtlv_entry_from_hex_string(&pxtlv,			&end, WL_NAN_XTLV_SVC_INFO, cmd_data->svc_info.data);		if (unlikely(ret)) {			goto fail;		}	}	nanioc->len = start - end;	nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;	ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,		cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);	if (unlikely(ret)) {		WL_ERR((" nan transmit failed, error = %d /n", ret));		goto fail;	} else {		WL_DBG((" nan transmit successful /n"));	}fail:	if (nanioc) {		kfree(nanioc);	}	return ret;}

intwl_cfgnan_cancel_sub_handler(struct net_device *ndev,	struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data){	wl_nan_ioc_t *nanioc = NULL;	struct bcm_tlvbuf *tbuf = NULL;	wl_nan_disc_params_t params;	s32 ret = BCME_OK;	u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;	uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;	/* proceed only if mandatory argument is present - subscriber id */	if (!cmd_data->sub_id) {		WL_ERR((" mandatory argument is not present /n"));		return -EINVAL;	}	nanioc = kzalloc(nanioc_size, kflags);	if (!nanioc) {		WL_ERR((" memory allocation failed /n"));		return -ENOMEM;	}	tbuf = bcm_xtlv_buf_alloc(NULL, BCM_XTLV_HDR_SIZE + sizeof(params));	if (!tbuf) {		WL_ERR((" memory allocation failed /n"));		ret = -ENOMEM;		goto fail;	}	/*	 * command to test	 *	 * wl: wl nan cancel_subscribe 10	 *	 * wpa_cli: DRIVER NAN_CANCEL_SUBSCRIBE PUB_ID=10	 */	bcm_xtlv_put_data(tbuf, WL_NAN_XTLV_INSTANCE_ID, &cmd_data->sub_id,		sizeof(wl_nan_instance_id_t));	/* nan cancel subscribe */	nanioc->version = htod16(WL_NAN_IOCTL_VERSION);	nanioc->id = htod16(WL_NAN_CMD_CANCEL_SUBSCRIBE);	nanioc->len = htod16(bcm_xtlv_buf_len(tbuf));	bcopy(bcm_xtlv_head(tbuf), nanioc->data, bcm_xtlv_buf_len(tbuf));	nanioc_size = sizeof(wl_nan_ioc_t) + bcm_xtlv_buf_len(tbuf);	ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,		cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);	if (unlikely(ret)) {		WL_ERR((" nan cancel subscribe failed, error = %d /n", ret));		goto fail;	} else {		WL_DBG((" nan cancel subscribe successful /n"));	}fail:	if (tbuf) {		bcm_xtlv_buf_free(NULL, tbuf);	}	if (nanioc) {		kfree(nanioc);	}	return ret;}

intwl_cfgnan_sub_handler(struct net_device *ndev,	struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data){	wl_nan_ioc_t *nanioc = NULL;	struct bcm_tlvbuf *tbuf = NULL;	wl_nan_disc_params_t params;	s32 ret = BCME_OK;	u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;	uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;	/*	 * proceed only if mandatory arguments are present - subscriber id,	 * service hash	 */	if ((!cmd_data->sub_id) || (!cmd_data->svc_hash.data) ||		(!cmd_data->svc_hash.dlen)) {		WL_ERR((" mandatory arguments are not present /n"));		return -EINVAL;	}	nanioc = kzalloc(nanioc_size, kflags);	if (!nanioc) {		WL_ERR((" memory allocation failed /n"));		return -ENOMEM;	}	tbuf = bcm_xtlv_buf_alloc(NULL, BCM_XTLV_HDR_SIZE + sizeof(params));	if (!tbuf) {		WL_ERR((" memory allocation failed /n"));		ret = -ENOMEM;		goto fail;	}	/*	 * command to test	 *	 * wl: wl nan subscribe 10 NAN123	 *	 * wpa_cli: DRIVER NAN_SUBSCRIBE SUB_ID=10 SVC_HASH=NAN123	 */	/* nan subscribe */	params.period = 1;	params.ttl = WL_NAN_TTL_UNTIL_CANCEL;	params.flags = 0;	params.instance_id = (wl_nan_instance_id_t)cmd_data->sub_id;	memcpy((char *)params.svc_hash, cmd_data->svc_hash.data,		cmd_data->svc_hash.dlen);	bcm_xtlv_put_data(tbuf, WL_NAN_XTLV_SVC_PARAMS, &params, sizeof(params));	nanioc->version = htod16(WL_NAN_IOCTL_VERSION);	nanioc->id = htod16(WL_NAN_CMD_SUBSCRIBE);	nanioc->len = htod16(bcm_xtlv_buf_len(tbuf));	bcopy(bcm_xtlv_head(tbuf), nanioc->data, bcm_xtlv_buf_len(tbuf));	nanioc_size = sizeof(wl_nan_ioc_t) + bcm_xtlv_buf_len(tbuf);	ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,		cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);	if (unlikely(ret)) {		WL_ERR((" nan subscribe failed, error = %d /n", ret));		goto fail;	} else {		WL_DBG((" nan subscribe successful /n"));	}fail:	if (tbuf) {		bcm_xtlv_buf_free(NULL, tbuf);	}	if (nanioc) {		kfree(nanioc);	}	return ret;}

intwl_cfgnan_pub_handler(struct net_device *ndev,	struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data){	wl_nan_ioc_t *nanioc = NULL;	struct bcm_tlvbuf *tbuf = NULL;	wl_nan_disc_params_t params;	s32 ret = BCME_OK;	u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;	uint16 tbuf_size = BCM_XTLV_HDR_SIZE + sizeof(params);	uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;	void *pxtlv;	u16 start, end;	/*	 * proceed only if mandatory arguments are present - publisher id,	 * service hash	 */	if ((!cmd_data->pub_id) || (!cmd_data->svc_hash.data) ||		(!cmd_data->svc_hash.dlen)) {		WL_ERR((" mandatory arguments are not present /n"));		return -EINVAL;	}	nanioc = kzalloc(nanioc_size, kflags);	if (!nanioc) {		WL_ERR((" memory allocation failed /n"));		return -ENOMEM;	}	tbuf = bcm_xtlv_buf_alloc(NULL, tbuf_size);	if (!tbuf) {		WL_ERR((" memory allocation failed /n"));		ret = -ENOMEM;		goto fail;	}	/*	 * command to test	 *	 * wl: wl nan publish 10 NAN123 -info <hex_string	 *     wl nan publish 10 NAN123 -info <hex_string -period 1 -ttl 0xffffffff	 *	 * wpa_cli: DRIVER NAN_PUBLISH PUB_ID=10 SVC_HASH=NAN123	 *          SVC_INFO=<hex_string>	 *          DRIVER NAN_PUBLISH PUB_ID=10 SVC_HASH=NAN123	 *          SVC_INFO=<hex_string> PUB_PR=1 PUB_INT=0xffffffff	 */	/* nan publish */	start = end = NAN_IOCTL_BUF_SIZE;	nanioc->version = htod16(WL_NAN_IOCTL_VERSION);	nanioc->id = htod16(WL_NAN_CMD_PUBLISH);	pxtlv = nanioc->data;	/* disovery parameters */	if (cmd_data->pub_pr) {		params.period = cmd_data->pub_pr;	} else {		params.period = 1;	}	if (cmd_data->pub_int) {		params.ttl = cmd_data->pub_int;	} else {		params.ttl = WL_NAN_TTL_UNTIL_CANCEL;	}	params.flags = WL_NAN_PUB_BOTH;	params.instance_id = (wl_nan_instance_id_t)cmd_data->pub_id;	memcpy((char *)params.svc_hash, cmd_data->svc_hash.data,		cmd_data->svc_hash.dlen);	ret = bcm_pack_xtlv_entry(&pxtlv,		&end, WL_NAN_XTLV_SVC_PARAMS, sizeof(wl_nan_disc_params_t), &params);	if (unlikely(ret)) {		goto fail;	}	if (cmd_data->svc_info.data && cmd_data->svc_info.dlen) {		WL_DBG((" optional svc_info present, pack it /n"));		ret = bcm_pack_xtlv_entry_from_hex_string(&pxtlv,			&end, WL_NAN_XTLV_SVC_INFO, cmd_data->svc_info.data);		if (unlikely(ret)) {			goto fail;		}	}	nanioc->len = start - end;	nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;	ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,		cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);	if (unlikely(ret)) {		WL_ERR((" nan publish failed, error = %d /n", ret));		goto fail;	} else {		WL_DBG((" nan publish successful /n"));	}fail:	if (tbuf) {		bcm_xtlv_buf_free(NULL, tbuf);	}	if (nanioc) {//.........这里部分代码省略.........

intwl_cfgnan_stop_handler(struct net_device *ndev,	struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data){	wl_nan_ioc_t *nanioc = NULL;	struct ether_addr cluster_id = ether_null;	void *pxtlv;	s32 ret = BCME_OK;	u16 start, end;	u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;	uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;	uint8 nan_enable = FALSE;	if (cfg->nan_running == false) {		WL_DBG((" nan not running, do nothing /n"));		return BCME_OK;	}	nanioc = kzalloc(nanioc_size, kflags);	if (!nanioc) {		WL_ERR((" memory allocation failed /n"));		return -ENOMEM;	}	/*	 * command to test	 *	 * wl: wl nan stop	 *     wl nan 0	 *	 * wpa_cli: DRIVER NAN_STOP	 */	/* nan stop */	start = end = NAN_IOCTL_BUF_SIZE;	nanioc->version = htod16(WL_NAN_IOCTL_VERSION);	nanioc->id = htod16(WL_NAN_CMD_STOP);	pxtlv = nanioc->data;	ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_CLUSTER_ID,		ETHER_ADDR_LEN, &cluster_id);	if (unlikely(ret)) {		goto fail;	}	nanioc->len = start - end;	nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;	ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,		cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);	if (unlikely(ret)) {		WL_ERR((" nan stop failed, error = %d /n", ret));		goto fail;	} else {		WL_DBG((" nan stop successful /n"));	}	/* nan disable */	memset(nanioc, 0, nanioc_size);	start = end = NAN_IOCTL_BUF_SIZE;	nanioc->version = htod16(WL_NAN_IOCTL_VERSION);	nanioc->id = htod16(WL_NAN_CMD_ENABLE);	pxtlv = nanioc->data;	ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_ENABLE,		sizeof(uint8), &nan_enable);	if (unlikely(ret)) {		goto fail;	}	nanioc->len = start - end;	nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;	ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,		cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);	if (unlikely(ret)) {		WL_ERR((" nan disable failed, error = %d /n", ret));		goto fail;	} else {		WL_DBG((" nan disable successful /n"));	}fail:	if (nanioc) {		kfree(nanioc);	}	return ret;}

intwl_cfgnan_enable_events(struct net_device *ndev, struct bcm_cfg80211 *cfg){	wl_nan_ioc_t *nanioc = NULL;	void *pxtlv;	u32 event_mask = 0;	s32 ret = BCME_OK;	u16 start, end;	u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;	uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;	nanioc = kzalloc(nanioc_size, kflags);	if (!nanioc) {		WL_ERR((" memory allocation failed /n"));		return -ENOMEM;	}	ret = wl_add_remove_eventmsg(ndev, WLC_E_NAN, true);	if (unlikely(ret)) {		WL_ERR((" nan event enable failed, error = %d /n", ret));		goto fail;	}	if (g_nan_debug) {		/* enable all nan events */		event_mask = NAN_EVENT_MASK_ALL;	} else {		/* enable only selected nan events to avoid unnecessary host wake up */		event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_START);		event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_JOIN);		event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_DISCOVERY_RESULT);		event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_RECEIVE);		event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_TERMINATED);		event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_STOP);		event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_CLEAR_BIT);		event_mask = htod32(event_mask);	}	start = end = NAN_IOCTL_BUF_SIZE;	nanioc->version = htod16(WL_NAN_IOCTL_VERSION);	nanioc->id = htod16(WL_NAN_CMD_EVENT_MASK);	pxtlv = nanioc->data;	ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_EVENT_MASK,		sizeof(uint32), &event_mask);	if (unlikely(ret)) {		goto fail;	}	nanioc->len = start - end;	nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;	ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,		cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);	if (unlikely(ret)) {		WL_ERR((" nan event selective enable failed, error = %d /n", ret));		goto fail;	} else {		WL_DBG((" nan event selective enable successful /n"));	}	ret = wl_add_remove_eventmsg(ndev, WLC_E_PROXD, true);	if (unlikely(ret)) {		WL_ERR((" proxd event enable failed, error = %d /n", ret));		goto fail;	}fail:	if (nanioc) {		kfree(nanioc);	}	return ret;}

int wldev_set_country(	struct net_device *dev, char *country_code, bool notify, bool user_enforced){	int error = -1;	wl_country_t cspec = {{0}, 0, {0}};	scb_val_t scbval;	char smbuf[WLC_IOCTL_SMLEN];//CY+ default country when set country fail	char default_country[10] = "XY";//CY-#ifdef CHIPNUM	uint chipnum = 0;#endif	if (!country_code)		return error;	bzero(&scbval, sizeof(scb_val_t));	error = wldev_iovar_getbuf(dev, "country", NULL, 0, &cspec, sizeof(cspec), NULL);	if (error < 0) {		WLDEV_ERROR(("%s: get country failed = %d/n", __FUNCTION__, error));		return error;	}//CY+ always set country#if 0	if ((error < 0) ||	    (strncmp(country_code, cspec.country_abbrev, WLC_CNTRY_BUF_SZ) != 0)) {#else	if(true){#endif//CY- always set country		if (user_enforced) {			bzero(&scbval, sizeof(scb_val_t));			error = wldev_ioctl(dev, WLC_DISASSOC, &scbval, sizeof(scb_val_t), true);			if (error < 0) {				WLDEV_ERROR(("%s: set country failed due to Disassoc error %d/n",					__FUNCTION__, error));				return error;			}		}		cspec.rev = -1;		memcpy(cspec.country_abbrev, country_code, WLC_CNTRY_BUF_SZ);		memcpy(cspec.ccode, country_code, WLC_CNTRY_BUF_SZ);#ifdef CHIPNUM		chipnum = dhd_get_chipnum(dev);		printk("%s: chipnum:%d/n", __FUNCTION__, chipnum);		dhd_get_customized_country_code(dev, (char *)&cspec.country_abbrev, &cspec, chipnum);//CY+ set default country//BCM43340: XY//BCM43362: XV//BCM4343s: XV		if (chipnum == 43430){			sprintf(default_country, "XV");		}else if (chipnum == 43362){			sprintf(default_country, "XV");		}else {			sprintf(default_country, "XY");		}		WLDEV_ERROR(("%s: set default country to %s for CHIP %d/n", __FUNCTION__, default_country, chipnum));//CY-#else		dhd_get_customized_country_code(dev, (char *)&cspec.country_abbrev, &cspec);#endif		error = wldev_iovar_setbuf(dev, "country", &cspec, sizeof(cspec),			smbuf, sizeof(smbuf), NULL);		if (error < 0) {			WLDEV_ERROR(("%s: set country for %s as %s rev %d failed, try to use %s/n",				__FUNCTION__, country_code, cspec.ccode, cspec.rev, default_country));			//return error;			//if set country error, use default_country			cspec.rev = -1;			memcpy(cspec.country_abbrev, default_country, WLC_CNTRY_BUF_SZ);			memcpy(cspec.ccode, default_country, WLC_CNTRY_BUF_SZ);#ifdef CHIPNUM			dhd_get_customized_country_code(dev, (char *)&cspec.country_abbrev, &cspec, chipnum);#else			dhd_get_customized_country_code(dev, (char *)&cspec.country_abbrev, &cspec);#endif			error = wldev_iovar_setbuf(dev, "country", &cspec, sizeof(cspec),				smbuf, sizeof(smbuf), NULL);			if (error < 0) {				WLDEV_ERROR(("%s: set country for %s as %s rev %d failed/n",					__FUNCTION__, country_code, cspec.ccode, cspec.rev));				return error;			}		}		dhd_bus_country_set(dev, &cspec, notify);		WLDEV_ERROR(("%s: set country for %s as %s rev %d/n",			__FUNCTION__, country_code, cspec.ccode, cspec.rev));	}//.........这里部分代码省略.........

int wldev_set_country(	struct net_device *dev, char *country_code, bool notify, bool user_enforced){	int error = -1;	wl_country_t cspec = {{0}, 0, {0}};	scb_val_t scbval;	char smbuf[WLC_IOCTL_SMLEN];#ifdef CUSTOMER_HW_ONE	uint32 chan_buf[WL_NUMCHANNELS];	wl_uint32_list_t *list;	channel_info_t ci;	int retry = 0;	int chan = 1;#endif	if (!country_code)		return error;	bzero(&scbval, sizeof(scb_val_t));	error = wldev_iovar_getbuf(dev, "country", NULL, 0, &cspec, sizeof(cspec), NULL);	if (error < 0) {		WLDEV_ERROR(("%s: get country failed = %d/n", __FUNCTION__, error));		return error;	}	if ((error < 0) ||	    (strncmp(country_code, cspec.country_abbrev, WLC_CNTRY_BUF_SZ) != 0)) {		if (user_enforced) {			bzero(&scbval, sizeof(scb_val_t));			error = wldev_ioctl(dev, WLC_DISASSOC, &scbval, sizeof(scb_val_t), true);			if (error < 0) {				WLDEV_ERROR(("%s: set country failed due to Disassoc error %d/n",					__FUNCTION__, error));				return error;			}		}#ifdef CUSTOMER_HW_ONE		error = wldev_ioctl(dev, WLC_SET_CHANNEL, &chan, sizeof(chan), 1);		if (error < 0) {			WLDEV_ERROR(("%s: set country failed due to channel 1 error %d/n",				__FUNCTION__, error));			return error;		}	}get_channel_retry:	if ((error = wldev_ioctl(dev, WLC_GET_CHANNEL, &ci, sizeof(ci), 0))) {		WLDEV_ERROR(("%s: get channel fail!/n", __FUNCTION__));		return error;	}	ci.scan_channel = dtoh32(ci.scan_channel);	if (ci.scan_channel) {		retry++;		printf("%s: scan in progress, retry %d!/n", __FUNCTION__, retry);		if (retry > 3)			return -EBUSY;		bcm_mdelay(1000);		goto get_channel_retry;	}#endif		cspec.rev = -1;		memcpy(cspec.country_abbrev, country_code, WLC_CNTRY_BUF_SZ);		memcpy(cspec.ccode, country_code, WLC_CNTRY_BUF_SZ);		get_customized_country_code((char *)&cspec.country_abbrev, &cspec);		error = wldev_iovar_setbuf(dev, "country", &cspec, sizeof(cspec),			smbuf, sizeof(smbuf), NULL);		if (error < 0) {#ifdef CUSTOMER_HW_ONE			if (strcmp(cspec.country_abbrev, DEF_COUNTRY_CODE) != 0) {				strcpy(country_code, DEF_COUNTRY_CODE);				retry = 0;				goto get_channel_retry;			}			else {#endif				WLDEV_ERROR(("%s: set country for %s as %s rev %d failed/n",					__FUNCTION__, country_code, cspec.ccode, cspec.rev));				return error;			}#ifdef CUSTOMER_HW_ONE		}		/* check if there are available channels */		else {			if (strcmp(country_code, DEF_COUNTRY_CODE) != 0) {				list = (wl_uint32_list_t *)(void *)chan_buf;				list->count = htod32(WL_NUMCHANNELS);				if ((error = wldev_ioctl_no_memset(dev, WLC_GET_VALID_CHANNELS, &chan_buf, sizeof(chan_buf), 0))) {					WLDEV_ERROR(("%s: get channel list fail! %d/n", __FUNCTION__, error));					return error;				}				/* if NULL, set default country code instead and set country code again */				printf("%s: channel_count = %d/n", __FUNCTION__, list->count);				if (list->count == 0) {					strcpy(country_code, DEF_COUNTRY_CODE);					retry = 0;					goto get_channel_retry;				}		}	#endif//.........这里部分代码省略.........

intwl_cfgnan_rtt_find_handler(struct net_device *ndev,	struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data){	void *iovbuf;	wl_nan_ranging_list_t *rtt_list;	s32 iovbuf_size = NAN_RTT_IOVAR_BUF_SIZE;	s32 ret = BCME_OK;	u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;	/*	 * proceed only if mandatory arguments are present - channel, bitmap,	 * mac address	 */	if ((!cmd_data->chanspec) || (!cmd_data->bmap) ||		ETHER_ISNULLADDR(&cmd_data->mac_addr.octet)) {		WL_ERR((" mandatory arguments are not present /n"));		return -EINVAL;	}	iovbuf = kzalloc(iovbuf_size, kflags);	if (!iovbuf) {		WL_ERR((" memory allocation failed /n"));		return -ENOMEM;	}	/*	 * command to test	 *	 * wl: wl proxd_nanfind 1 44/80 <mac_addr> 0x300 5 6 1	 *	 * wpa_cli: DRIVER NAN_RTT_FIND MAC_ADDR=<mac_addr> CHAN=44/80 BMAP=0x300	 *	 */	rtt_list = (wl_nan_ranging_list_t *)iovbuf;	rtt_list->count = 1;	rtt_list->num_peers_done = 0;	rtt_list->num_dws = 1;	rtt_list->rp[0].chanspec = cmd_data->chanspec;	memcpy(&rtt_list->rp[0].ea, &cmd_data->mac_addr,		sizeof(struct ether_addr));	rtt_list->rp[0].abitmap = cmd_data->bmap;	rtt_list->rp[0].frmcnt = 5;	rtt_list->rp[0].retrycnt = 6;	rtt_list->rp[0].flags = 1;	iovbuf_size = sizeof(wl_nan_ranging_list_t) +		sizeof(wl_nan_ranging_peer_t);	ret = wldev_iovar_setbuf(ndev, "proxd_nanfind", iovbuf,		iovbuf_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);	if (unlikely(ret)) {		WL_ERR((" nan rtt find failed, error = %d /n", ret));	} else {		WL_DBG((" nan rtt find successful /n"));	}	if (iovbuf) {		kfree(iovbuf);	}	return ret;}

int wl_android_set_ibss_beacon_ouidata(struct net_device *dev, char *command, int total_len){	char ie_buf[VNDR_IE_MAX_LEN];	char *ioctl_buf = NULL;	char hex[] = "XX";	char *pcmd = NULL;	int ielen = 0, datalen = 0, idx = 0, tot_len = 0;	vndr_ie_setbuf_t *vndr_ie = NULL;	s32 iecount;	uint32 pktflag;	u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;	s32 err = BCME_OK;	/* Check the VSIE (Vendor Specific IE) which was added.	 *  If exist then send IOVAR to delete it	 */	if (wl_cfg80211_ibss_vsie_delete(dev) != BCME_OK) {		return -EINVAL;	}	pcmd = command + strlen(CMD_SETIBSSBEACONOUIDATA) + 1;	for (idx = 0; idx < DOT11_OUI_LEN; idx++) {		hex[0] = *pcmd++;		hex[1] = *pcmd++;		ie_buf[idx] =  (uint8)simple_strtoul(hex, NULL, 16);	}	pcmd++;	while ((*pcmd != '/0') && (idx < VNDR_IE_MAX_LEN)) {		hex[0] = *pcmd++;		hex[1] = *pcmd++;		ie_buf[idx++] =  (uint8)simple_strtoul(hex, NULL, 16);		datalen++;	}	tot_len = sizeof(vndr_ie_setbuf_t) + (datalen - 1);	vndr_ie = (vndr_ie_setbuf_t *) kzalloc(tot_len, kflags);	if (!vndr_ie) {		WL_ERR(("IE memory alloc failed/n"));		return -ENOMEM;	}	/* Copy the vndr_ie SET command ("add"/"del") to the buffer */	strncpy(vndr_ie->cmd, "add", VNDR_IE_CMD_LEN - 1);	vndr_ie->cmd[VNDR_IE_CMD_LEN - 1] = '/0';	/* Set the IE count - the buffer contains only 1 IE */	iecount = htod32(1);	memcpy((void *)&vndr_ie->vndr_ie_buffer.iecount, &iecount, sizeof(s32));	/* Set packet flag to indicate that BEACON's will contain this IE */	pktflag = htod32(VNDR_IE_BEACON_FLAG | VNDR_IE_PRBRSP_FLAG);	memcpy((void *)&vndr_ie->vndr_ie_buffer.vndr_ie_list[0].pktflag, &pktflag,		sizeof(u32));	/* Set the IE ID */	vndr_ie->vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.id = (uchar) DOT11_MNG_PROPR_ID;	memcpy(&vndr_ie->vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.oui, &ie_buf,		DOT11_OUI_LEN);	memcpy(&vndr_ie->vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.data,		&ie_buf[DOT11_OUI_LEN], datalen);	ielen = DOT11_OUI_LEN + datalen;	vndr_ie->vndr_ie_buffer.vndr_ie_list[0].vndr_ie_data.len = (uchar) ielen;	ioctl_buf = kmalloc(WLC_IOCTL_MEDLEN, GFP_KERNEL);	if (!ioctl_buf) {		WL_ERR(("ioctl memory alloc failed/n"));		if (vndr_ie) {			kfree(vndr_ie);		}		return -ENOMEM;	}	memset(ioctl_buf, 0, WLC_IOCTL_MEDLEN);	/* init the buffer */	err = wldev_iovar_setbuf(dev, "ie", vndr_ie, tot_len, ioctl_buf, WLC_IOCTL_MEDLEN, NULL);	if (err != BCME_OK) {		err = -EINVAL;		if (vndr_ie) {			kfree(vndr_ie);		}	}	else {		/* do NOT free 'vndr_ie' for the next process */		wl_cfg80211_ibss_vsie_set_buffer(vndr_ie, tot_len);	}	if (ioctl_buf) {		kfree(ioctl_buf);	}	return err;}

intwl_cfgnan_set_config_handler(struct net_device *ndev,	struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data){	wl_nan_ioc_t *nanioc = NULL;	void *pxtlv;	s32 ret = BCME_OK;	u16 start, end;	u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;	uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;	nanioc = kzalloc(nanioc_size, kflags);	if (!nanioc) {		WL_ERR((" memory allocation failed /n"));		return -ENOMEM;	}	/*	 * command to test	 *	 * wl: wl nan <attr> <value> (wl nan role 1)	 *	 * wpa_cli: DRIVER NAN_CONFIG_SET ATTR=<attr> <value>...<value>	 *	 * wpa_cli: DRIVER NAN_SET_CONFIG ATTR=ATTR_ROLE ROLE=1	 */	/* nan set config */	start = end = NAN_IOCTL_BUF_SIZE;	nanioc->version = htod16(WL_NAN_IOCTL_VERSION);	nanioc->id = htod16(WL_NAN_CMD_ATTR);	pxtlv = nanioc->data;	switch (cmd_data->attr.type) {	case WL_NAN_XTLV_ROLE:		ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_ROLE,			sizeof(u32), &cmd_data->role);		break;	case WL_NAN_XTLV_MASTER_PREF:		ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_MASTER_PREF,			sizeof(u16), &cmd_data->master_pref);		break;	case WL_NAN_XTLV_DW_LEN:		ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_DW_LEN,			sizeof(u16), &cmd_data->dw_len);		break;	case WL_NAN_XTLV_CLUSTER_ID:	case WL_NAN_XTLV_IF_ADDR:	case WL_NAN_XTLV_BCN_INTERVAL:	case WL_NAN_XTLV_MAC_CHANSPEC:	case WL_NAN_XTLV_MAC_TXRATE:	default:		ret = -EINVAL;		break;	}	if (unlikely(ret)) {		WL_ERR((" unsupported attribute, attr = %s (%d) /n",			cmd_data->attr.name, cmd_data->attr.type));		goto fail;	}	nanioc->len = start - end;	nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;	ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,		cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);	if (unlikely(ret)) {		WL_ERR((" nan set config failed, error = %d /n", ret));		goto fail;	} else {		WL_DBG((" nan set config successful /n"));	}fail:	if (nanioc) {		kfree(nanioc);	}	return ret;}

int wldev_set_country(	struct net_device *dev, char *country_code){	int error = -1;	wl_country_t cspec = {{0}, 0, {0}};	scb_val_t scbval;	char smbuf[WLC_IOCTL_SMLEN];	if (!country_code)		return error;	error = wldev_iovar_getbuf(dev, "country", &cspec, sizeof(cspec),		smbuf, sizeof(smbuf), NULL);	if (error < 0)		WLDEV_ERROR(("%s: get country failed = %d/n", __FUNCTION__, error));	if ((error < 0) ||	    (strncmp(country_code, smbuf, WLC_CNTRY_BUF_SZ) != 0)) {		bzero(&scbval, sizeof(scb_val_t));		error = wldev_ioctl(dev, WLC_DISASSOC, &scbval, sizeof(scb_val_t), 1);		if (error < 0) {			WLDEV_ERROR(("%s: set country failed due to Disassoc error %d/n",				__FUNCTION__, error));			return error;		}	}	cspec.rev = -1;	//[email
C++ wldev_iovar_setint函数代码示例
C++ wldev_iovar_getbuf函数代码示例