iwctl.c

VIA VT6656 USB linux source code.

            if ((pBSS->wWPALen > 0) && (pBSS->wWPALen <= MAX_WPA_IE_LEN)) {
                u8 *p = buf;
                memset(&iwe, 0, sizeof(iwe));
                iwe.cmd = IWEVCUSTOM;
		        p += sprintf(p, "wpa_ie=");
		        for (ii = 0; ii < pBSS->wWPALen; ii++) {
			        p += sprintf(p, "%02x", pBSS->byWPAIE[ii]);
		        }
		        iwe.u.data.length = strlen(buf);
		        current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, buf);
		    }    
                                
                                
            if ((pBSS->wRSNLen > 0) && (pBSS->wRSNLen <= MAX_WPA_IE_LEN)) {
                u8 *p = buf;
                memset(&iwe, 0, sizeof(iwe));
                iwe.cmd = IWEVCUSTOM;
		        p += sprintf(p, "rsn_ie=");
		        for (ii = 0; ii < pBSS->wRSNLen; ii++) {
			        p += sprintf(p, "%02x", pBSS->byRSNIE[ii]);
		        }
		        iwe.u.data.length = strlen(buf);
		        current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, buf);
		    }
#endif		    
#endif		        
        }  
    }// for 
    
	wrq->length = current_ev - extra;
	return 0;

}

#endif	/* WIRELESS_EXT > 13 */


/*
 * Wireless Handler : set frequence or channel
 */

int iwctl_siwfreq(struct net_device *dev,
             struct iw_request_info *info,
             struct iw_freq *wrq,
             char *extra)
{
	PSDevice	        pDevice = (PSDevice)dev->priv;
	int rc = 0;
	    
    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWFREQ \n");	

	// If setting by frequency, convert to a channel 
	if((wrq->e == 1) &&
	   (wrq->m >= (int) 2.412e8) &&
	   (wrq->m <= (int) 2.487e8)) {
		int f = wrq->m / 100000;
		int c = 0;
		while((c < 14) && (f != frequency_list[c]))
			c++;
		wrq->e = 0;
		wrq->m = c + 1;
	}		
	// Setting by channel number 
	if((wrq->m > 14) || (wrq->e > 0))
		rc = -EOPNOTSUPP;
	else {
		int channel = wrq->m;
		if((channel < 1) || (channel > 14)) {
			DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: New channel value of %d is invalid!\n", dev->name, wrq->m);
			rc = -EINVAL;
		} else {
			  // Yes ! We can set it !!! 
              DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Set to channel = %d\n", channel);
			  pDevice->uChannel = channel;
		}
	}    
    
	return rc;
}

/*
 * Wireless Handler : get frequence or channel
 */

int iwctl_giwfreq(struct net_device *dev,
             struct iw_request_info *info,
             struct iw_freq *wrq,
             char *extra)
{
	PSDevice	        pDevice = (PSDevice)dev->priv;
    PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);    
    
    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWFREQ \n");    
    
#ifdef WEXT_USECHANNELS
	wrq->m = (int)pMgmt->uCurrChannel;
	wrq->e = 0;
#else
	{
		int f = (int)pMgmt->uCurrChannel - 1;
		if(f < 0)
		   f = 0;
		wrq->m = frequency_list[f] * 100000;
		wrq->e = 1;
	}
#endif    
    
	return 0;
}

/*
 * Wireless Handler : set operation mode
 */

int iwctl_siwmode(struct net_device *dev,
             struct iw_request_info *info,
             __u32 *wmode,
             char *extra)
{
	PSDevice	        pDevice = (PSDevice)dev->priv;
    PSMgmtObject        pMgmt = &(pDevice->sMgmtObj); 
    int rc = 0;
    
    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMODE \n");	
    
    if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP && pDevice->bEnableHostapd) {
        DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Can't set operation mode, hostapd is running \n");
        return rc;
    }
         
	switch(*wmode) {

	case IW_MODE_ADHOC:
	    if (pMgmt->eConfigMode != WMAC_CONFIG_IBSS_STA) { 
            pMgmt->eConfigMode = WMAC_CONFIG_IBSS_STA;
            if (pDevice->flags & DEVICE_FLAGS_OPENED) {
		        pDevice->bCommit = TRUE;
   		    }
		}
        DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to ad-hoc \n");
		break;
	case IW_MODE_AUTO:			
	case IW_MODE_INFRA:
	    if (pMgmt->eConfigMode != WMAC_CONFIG_ESS_STA) { 
            pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
            if (pDevice->flags & DEVICE_FLAGS_OPENED) {
		        pDevice->bCommit = TRUE;
   		    }                
		}
        DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to infrastructure \n");
		break;
	case IW_MODE_MASTER:
	
        pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
		rc = -EOPNOTSUPP;            
		break;

	    if (pMgmt->eConfigMode != WMAC_CONFIG_AP) { 
            pMgmt->eConfigMode = WMAC_CONFIG_AP;
            if (pDevice->flags & DEVICE_FLAGS_OPENED) {
		        pDevice->bCommit = TRUE;
   		    }                
		}
        DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to Access Point \n");
		break;

	case IW_MODE_REPEAT:
        pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
		rc = -EOPNOTSUPP;
		break;
	default:
		rc = -EINVAL;
	}    
    
	return rc;
}

/*
 * Wireless Handler : get operation mode
 */

int iwctl_giwmode(struct net_device *dev,
             struct iw_request_info *info,
             __u32 *wmode,
             char *extra)
{
	PSDevice	        pDevice = (PSDevice)dev->priv;
    PSMgmtObject        pMgmt = &(pDevice->sMgmtObj); 


    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWMODE \n");		
	// If not managed, assume it's ad-hoc 
	switch (pMgmt->eConfigMode) {
	case WMAC_CONFIG_ESS_STA:
		*wmode = IW_MODE_INFRA;
		break;
	case WMAC_CONFIG_IBSS_STA:
        *wmode = IW_MODE_ADHOC;
		break;
	case WMAC_CONFIG_AUTO:
		*wmode = IW_MODE_INFRA;
		break;
	case WMAC_CONFIG_AP:
		*wmode = IW_MODE_MASTER;
		break;			
	default:
		*wmode = IW_MODE_ADHOC;
	}
    
	return 0;
}


/*
 * Wireless Handler : get capability range
 */

int iwctl_giwrange(struct net_device *dev,
             struct iw_request_info *info,
             struct iw_point *wrq,
             char *extra)
{
	struct iw_range *range = (struct iw_range *) extra;    
	int		i,k;
    BYTE abySupportedRates[13]= {0x02, 0x04, 0x0B, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x90};    
//2008-0409-02, <Mark> by Einsn Liu
/*
 #ifdef Safe_Close
  PSDevice	        pDevice = (PSDevice)dev->priv;
  if (!(pDevice->flags & DEVICE_FLAGS_OPENED))
        return -EINVAL; 
#endif
 */   
    
    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWRANGE \n");	
	if (wrq->pointer) {
		wrq->length = sizeof(struct iw_range);
		memset(range, 0, sizeof(struct iw_range));
		range->min_nwid = 0x0000;
		range->max_nwid = 0x0000;
		range->num_channels = 14;
		// Should be based on cap_rid.country to give only
		//  what the current card support 
		k = 0;
		for(i = 0; i < 14; i++) {
			range->freq[k].i = i + 1; // List index 
			range->freq[k].m = frequency_list[i] * 100000;
			range->freq[k++].e = 1;	// Values in table in MHz -> * 10^5 * 10 
		}
		range->num_frequency = k;
		// Hum... Should put the right values there 
	     #ifdef Calcu_LinkQual
                 range->max_qual.qual = 100;
	     #else
		range->max_qual.qual = 255;
	     #endif
		range->max_qual.level = 0;	 
		range->max_qual.noise = 0;
		range->sensitivity = 255;

		for(i = 0 ; i < 13 ; i++) {
			range->bitrate[i] = abySupportedRates[i] * 500000;
			if(range->bitrate[i] == 0)
				break;
		}
		range->num_bitrates = i;

		// Set an indication of the max TCP throughput
		// in bit/s that we can expect using this interface.
		//  May be use for QoS stuff... Jean II 
		if(i > 2)
			range->throughput = 5 * 1000 * 1000;
		else
			range->throughput = 1.5 * 1000 * 1000;

		range->min_rts = 0;
		range->max_rts = 2312;
		range->min_frag = 256;
		range->max_frag = 2312;
		
		
	    // the encoding capabilities 
	    range->num_encoding_sizes = 3;
	    // 64(40) bits WEP 
	    range->encoding_size[0] = 5;
	    // 128(104) bits WEP 
	    range->encoding_size[1] = 13;
	    // 256 bits for WPA-PSK 
	    range->encoding_size[2] = 32;
	    // 4 keys are allowed 
	    range->max_encoding_tokens = 4;		

#if WIRELESS_EXT > 17
	    range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
		    IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
#endif 

#if WIRELESS_EXT > 9
		range->min_pmp = 0;
		range->max_pmp = 1000000;// 1 secs 
		range->min_pmt = 0;
		range->max_pmt = 1000000;// 1 secs	
		range->pmp_flags = IW_POWER_PERIOD;
		range->pmt_flags = IW_POWER_TIMEOUT;
		range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;

		// Transmit Power - values are in mW 

        range->txpower[0] = 100;
		range->num_txpower = 1;
		range->txpower_capa = IW_TXPOW_MWATT;
#endif // WIRELESS_EXT > 9 
#if WIRELESS_EXT > 10
		range->we_version_source = SUPPORTED_WIRELESS_EXT;
		range->we_version_compiled = WIRELESS_EXT;
		range->retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
		range->retry_flags = IW_RETRY_LIMIT;
		range->r_time_flags = IW_RETRY_LIFETIME;
		range->min_retry = 1;
		range->max_retry = 65535;
		range->min_r_time = 1024;
		range->max_r_time = 65535 * 1024;
#endif // WIRELESS_EXT > 10 
#if WIRELESS_EXT > 11
		// Experimental measurements - boundary 11/5.5 Mb/s 
		// Note : with or without the (local->rssi), results
		//  are somewhat different. - Jean II 
		range->avg_qual.qual = 6;
		range->avg_qual.level = 176;	// -80 dBm 
		range->avg_qual.noise = 0;
#endif // WIRELESS_EXT > 11 
	}    
    
    
	return 0;
}


/*
 * Wireless Handler : set ap mac address
 */

int iwctl_siwap(struct net_device *dev,
             struct iw_request_info *info,
			 struct sockaddr *wrq,             
             char *extra)
{
	PSDevice	        pDevice = (PSDevice)dev->priv;    
    PSMgmtObject        pMgmt = &(pDevice->sMgmtObj); 	
    int rc = 0;
    
   printk(" SIOCSIWAP \n");

	if (wrq->sa_family != ARPHRD_ETHER)
		rc = -EINVAL;
	else {
		memset(pMgmt->abyDesireBSSID, 0xFF, 6);
		memcpy(pMgmt->abyDesireBSSID, wrq->sa_data, 6);

        if (pDevice->flags & DEVICE_FLAGS_OPENED) {
		    pDevice->bCommit = TRUE;
   		}			
	}    
	return rc;
}

/*
 * Wireless Handler : get ap mac address
 */

int iwctl_giwap(struct net_device *dev,
             struct iw_request_info *info,
			 struct sockaddr *wrq,                          
             char *extra)
{
	PSDevice	        pDevice = (PSDevice)dev->priv;    
    PSMgmtObject        pMgmt = &(pDevice->sMgmtObj); 	
        
    
    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAP \n");
    
    memcpy(wrq->sa_data, pMgmt->abyCurrBSSID, 6);

//20080123-02,<Modify> by Einsn Liu
 if ((pDevice->bLinkPass == FALSE) && (pMgmt->eCurrMode != WMAC_MODE_ESS_AP))
 //   if ((pDevice->bLinkPass == FALSE) && (pMgmt->eCurrMode == WMAC_MODE_ESS_STA))
        memset(wrq->sa_data, 0, 6);
	    
    if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
        memcpy(wrq->sa_data, pMgmt->abyCurrBSSID, 6);
    }    

	wrq->sa_family = ARPHRD_ETHER;
	
	return 0;
    
}


/*
 * Wireless Handler : get ap list
 */

int iwctl_giwaplist(struct net_device *dev,
             struct iw_request_info *info,
             struct iw_point *wrq,
             char *extra)
{
	int ii,jj, rc = 0;
	struct sockaddr sock[IW_MAX_AP];
	struct iw_quality qual[IW_MAX_AP];    
	PSDevice	        pDevice = (PSDevice)dev->priv;    
    PSMgmtObject        pMgmt = &(pDevice->sMgmtObj); 	  	
	
    
    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAPLIST \n");	
	// Only super-user can see AP list
	
	if (!capable(CAP_NET_ADMIN)) {
		rc = -EPERM;
		return rc;
	}

	if (wrq->pointer) {

		PKnownBSS pBSS = &(pMgmt->sBSSList[0]);			

		for (ii = 0, jj= 0; ii < MAX_BSS_NUM; ii++) {
		    pBSS = &(pMgmt->sBSSList[ii]);
            if (!pBSS->bActive)
                continue;
            if ( jj >= IW_MAX_AP)
                break;   			    
			memcpy(sock[jj].sa_data, pBSS->abyBSSID, 6);
			sock[jj].sa_family = ARPHRD_ETHER;
			qual[jj].level = pBSS->uRSSI;
			qual[jj].qual = qual[jj].noise = 0;
			qual[jj].updated = 2;
			jj++;