linux.cpp

atmel芯片的Linux驱动程序。很多802.11协议的无限网卡都使用该芯片

/* Linux.cpp */
/*******************************************************************************************
	Copyright 2002-2003 ATMEL Corporation.

	This file is part of ATMEL Wireless LAN Drivers.

	ATMEL Wireless LAN Drivers is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	ATMEL Wireless LAN Drivers is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with ATMEL Wireless LAN Drivers; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*******************************************************************************************/

#include "Linux.h"
#include "Device.h"
#include "OSHeaders.h"
#include "WinterDebug.h"


// CVnetDeviceLinux class implementation
//=========================================
CVnetDeviceLinux::CVnetDeviceLinux( int sock, const wxString &devname ) : CVnetDeviceBase( devname )
{
	mFd = sock;
}

CVnetDeviceLinux::~CVnetDeviceLinux( )
{
	close( mFd );
}

bool CVnetDeviceLinux::IsOk( )
{
	return mFd >= 0;
}

int CVnetDeviceLinux::GetAPInfo( CBssInfoData dest[ MAX_BSS_ENTRIES ] )
{
	CWinterRuf ruf;
	ruf.Log( "GET_AP_INFO" );


	int found=0, i;
  	struct iwreq wrq;
	struct iw_event * piwe;
	BSS_INFO_EX dummy[ MAX_BSS_ENTRIES ];
	unsigned char buff[IW_SCAN_MAX_DATA];
	unsigned char* index=buff;

	strcpy( wrq.ifr_name, mDevName.c_str( ) );

	wrq.u.data.length = sizeof(buff);
	wrq.u.data.pointer = (caddr_t)buff;
	wrq.u.data.flags = 0;

	// no-response timeout is 10 seconds
	for(i=0; ioctl(mFd, SIOCGIWSCAN, &wrq) && i<10; i++) wxSleep(1);
	wxSleep(2);

	while(index < buff+wrq.u.data.length && found < MAX_BSS_ENTRIES) {	
		piwe = (struct iw_event*)index;
		switch(piwe->cmd) {
			case SIOCGIWAP:
				memcpy(dummy[found].BSSID, piwe->u.ap_addr.sa_data, 6);
				break;
			case SIOCGIWESSID:
				dummy[found].SSIDsize = piwe->u.data.length;
                		strcpy((char*)dummy[found].SSID, (char*)piwe+IW_EV_POINT_LEN); // piwe->u.data.length);
				break;
			case SIOCGIWMODE:
                		dummy[found].BSStype= piwe->u.mode;
				break;
			case SIOCGIWFREQ:
                		dummy[found].Channel= piwe->u.freq.m;
				break;
			case SIOCGIWENCODE:
				dummy[found].UsingWEP= (piwe->u.data.flags & IW_ENCODE_DISABLED ? 0: 1);
				found++;
				break;
			default:
				if(!piwe->len) return found; // deadlock preventer
				break;
		}
		index += (int) (piwe->len);
	} 
	for( int c = 0; c < found; c++ )
	{
		dest[c].Import( &dummy[ c ] );
	}
	return found; 
}

bool CVnetDeviceLinux::StartSiteSurvey( )
{
	CWinterRuf ruf;
	ruf.Log( "SITE_SURVEY" );

	struct iwreq wrq;

	strcpy( wrq.ifr_name, mDevName.c_str( ) );
	wrq.u.data.pointer = NULL;
	wrq.u.data.length = 0;

	if( ioctl( mFd, SIOCSIWSCAN, &wrq) != 0 )
	{
		return false;
	}

	return true;
}

bool CVnetDeviceLinux::StopSiteSurvey( )
{
	CWinterRuf ruf;
	ruf.Log( "STOP_SITE_SURVEY" );

	struct iwreq wrq;

	strcpy( wrq.ifr_name, mDevName.c_str( ) );
	wrq.u.data.pointer = NULL;
	wrq.u.data.length = 0;
	wrq.u.data.flags = STOP_SITE_SURVEY;
	if( ioctl( mFd, SIOCDEVPRIVATE, &wrq) != 0 )
	{
		return false;
	}

	return true;
}

int CVnetDeviceLinux::GetSiteSurveyState( )
{
	CWinterRuf ruf;
	ruf.Log( "SITE_SURVEY_STATE" );

	struct iwreq wrq;
	struct iw_event * piwe;
	unsigned char buff[IW_SCAN_MAX_DATA];

	strcpy( wrq.ifr_name, mDevName.c_str( ) );
	wrq.u.data.length = sizeof(buff);
	wrq.u.data.pointer = (caddr_t)buff;
	wrq.u.data.flags = 0;
	
	if( ioctl( mFd, SIOCGIWSCAN, &wrq) != 0 )
	{
		//return SITE_SURVEY_COMPLETED;
		return SITE_SURVEY_IN_PROGRESS;
	}
	return SITE_SURVEY_COMPLETED;
}

bool CVnetDeviceLinux::SelectAPByIndex( int index )
{
	CWinterRuf ruf;
	ruf.Log( "SELECT_AP_BY_INDEX" );

	int dummy = index;
	struct iwreq wrq;

	strcpy( wrq.ifr_name, mDevName.c_str( ) );
	wrq.u.data.pointer = ( caddr_t ) &dummy;
	wrq.u.data.length = sizeof( int );
	wrq.u.data.flags = SELECT_AP_BY_INDEX;
	if( ioctl( mFd, SIOCDEVPRIVATE, &wrq) != 0 )
	{
		return false;
	}

	return true;
}

bool CVnetDeviceLinux::GetDeviceConfig( CDeviceConfigurationData *dest )
{
	CWinterRuf ruf;
	ruf.Log( "GET_SUPPORT_INFO" );

	DEVICE_CONFIGURATION dummy;
	struct iwreq wrq;

	strcpy( wrq.ifr_name, mDevName.c_str( ) );
	wrq.u.data.pointer = ( caddr_t ) &dummy;
	wrq.u.data.length = 0;
	wrq.u.data.flags = GET_SUPPORT_INFO;
	if( ioctl( mFd, SIOCDEVPRIVATE, &wrq) != 0 )
	{
		return false;
	}

// debug:
ruf.RufStruct( &dummy );

	dest->Import( &dummy );
	return true;
}

bool CVnetDeviceLinux::SetDeviceConfig( CDeviceConfigurationData *src )
{
	CWinterRuf ruf;
	ruf.Log( "SET_SUPPORT_INFO" );

	DEVICE_CONFIGURATION dummy;
	struct iwreq wrq;

	src->Export( &dummy );
	
	strcpy( wrq.ifr_name, mDevName.c_str( ) );
	wrq.u.data.pointer = ( caddr_t ) &dummy;
	wrq.u.data.length = sizeof( DEVICE_CONFIGURATION );
	wrq.u.data.flags = SET_SUPPORT_INFO;
	if( ioctl( mFd, SIOCDEVPRIVATE, &wrq) != 0 )
	{
		return false;
	}

	return true;
}

bool CVnetDeviceLinux::GetStatistics( CStatisticsData *data )
{
	CWinterRuf ruf;
	ruf.Log( "GET_STATISTICS" );

 	STATISTICS dummy;
	struct iwreq wrq;
 	 	
 	strcpy( wrq.ifr_name, mDevName.c_str( ) );
 	wrq.u.data.length = 0;
 	wrq.u.data.flags = GET_STATISTICS;
 	wrq.u.data.pointer = ( caddr_t ) &dummy;
 	if( ioctl( mFd, SIOCDEVPRIVATE, &wrq ) != 0 )
	{
		return false;
	}

	data->Import( &dummy );
	return true;
}

bool CVnetDeviceLinux::GetMacAddress( CMacAddressData *data )
{
	CWinterRuf ruf;
	ruf.Log( "GET_MAC_ADDRESS" );

	UCHAR dummy[ 6 ];
	struct iwreq wrq;

	strcpy( wrq.ifr_name, mDevName.c_str( ) );
	wrq.u.data.pointer = ( caddr_t ) &dummy;
	wrq.u.data.length = 0;
	wrq.u.data.flags = GET_MAC_ADDRESS;
	if( ioctl( mFd, SIOCDEVPRIVATE, &wrq ) != 0 )
	{
		return false;
	}

	data->Import( dummy );
	return true;
}

bool CVnetDeviceLinux::GetWepInfo( CWepInfoData *data )
{
	CWinterRuf ruf;
	ruf.Log( "GET_WEP_INFO" );

	ENCRYPTION_INFO dummy;
	unsigned char key[IW_ENCODING_TOKEN_MAX];
	struct iwreq wrq;

	strcpy( wrq.ifr_name, mDevName.c_str( ) );
	wrq.u.data.pointer = (caddr_t) key;
	wrq.u.data.length=IW_ENCODING_TOKEN_MAX;
	wrq.u.data.flags=0;
	if(ioctl(mFd, SIOCGIWENCODE, &wrq) < 0) {
		return false;
	}

	dummy.WepKeyToUse = (wrq.u.data.flags & 0x7) -1;
	
	if(wrq.u.data.flags & IW_ENCODE_DISABLED) {
		dummy.EncryptionLevel =0;
		dummy.WepKeyToUse =0;
	}  else { 
		dummy.EncryptionLevel =  (wrq.u.data.length == 5 ? WEP_64BIT : WEP_128BIT ) ;
		dummy.AuthenticationType = (wrq.u.data.flags & IW_ENCODE_OPEN) ? C80211_MGMT_AAN_OPENSYSTEM : C80211_MGMT_AAN_SHAREDKEY;
		memcpy((PUCHAR)dummy.KeyMaterial[dummy.WepKeyToUse], (PUCHAR)wrq.u.data.pointer, wrq.u.data.length);	
	}		

	data->Import( &dummy );
	return true;
}

bool CVnetDeviceLinux::SetWepInfo( CWepInfoData *data )
{
	CWinterRuf ruf;
	ruf.Log( "SET_WEP_INFO" );

	ENCRYPTION_INFO dummy;
	struct iwreq wrq;

	data->Export( &dummy );
	strcpy( wrq.ifr_name, mDevName.c_str( ) );
	
	//wrq.u.data.pointer = (caddr_t)&dummy;
	wrq.u.data.length = sizeof(ENCRYPTION_INFO);

	wrq.u.data.flags = dummy.WepKeyToUse+1;
	wrq.u.data.flags |= (dummy.EncryptionLevel ? IW_ENCODE_ENABLED : IW_ENCODE_DISABLED);
	wrq.u.data.flags |= (dummy.AuthenticationType == C80211_MGMT_AAN_OPENSYSTEM ? IW_ENCODE_OPEN : IW_ENCODE_RESTRICTED);
	if(dummy.EncryptionLevel)
		wrq.u.data.length = (dummy.EncryptionLevel == WEP_64BIT ? 5 : 13);
	else	wrq.u.data.length = 0;	

	wrq.u.data.pointer = (caddr_t) (dummy.KeyMaterial[dummy.WepKeyToUse]);
	
   	if (ioctl(mFd, SIOCSIWENCODE, &wrq) < 0) {
       		return false;
       	}
   	return true;
}

bool CVnetDeviceLinux::GetVersionInfo( CVersionInfoData *data )
{
	CWinterRuf ruf;
	ruf.Log( "GET_VERSION_INFO" );

	VERSION_INFO dummy;

	struct iwreq wrq;
	strcpy( wrq.ifr_name, mDevName.c_str() );
	wrq.u.data.length = 0;
	wrq.u.data.flags = GET_VERSION_INFO;
	wrq.u.data.pointer = ( caddr_t ) &dummy;

	if( ioctl( mFd, SIOCDEVPRIVATE, &wrq ) != 0 )
	{
		return false;
	}

	data->Import( &dummy );
	return true;
}

bool CVnetDeviceLinux::ResetCard( )
{
	struct iwreq wrq;
	return false;
}

bool CVnetDeviceLinux::ClearPackets( )
{
	CWinterRuf ruf;
	ruf.Log( "CLEAR_PACKETS" );

	struct iwreq wrq;
	strcpy( wrq.ifr_name, mDevName.c_str() );
	wrq.u.data.length = 0;
	wrq.u.data.flags = CLEAR_PACKETS;
	wrq.u.data.pointer = ( caddr_t ) NULL;

	if( ioctl( mFd, SIOCDEVPRIVATE, &wrq ) != 0 )
	{
		return false;
	}

	return true;
}

/* For GUI	*/
bool CVnetDeviceLinux::SendSelectedAP( )
{
	return false;
}


static int open_socket( )
{
	int inet_sock = -1;
	int ipx_sock = -1;
	int ax25_sock = -1;
	int ddp_sock = -1;
	
	inet_sock = socket( AF_INET, SOCK_STREAM, 0 );
	ipx_sock = socket( AF_IPX, SOCK_STREAM, 0 );
	ax25_sock = socket( AF_AX25, SOCK_STREAM, 0 );
	ddp_sock = socket( AF_APPLETALK, SOCK_STREAM, 0 );

	if( inet_sock != -1 )
		return inet_sock;

	if( ipx_sock != -1 )
		return ipx_sock;

	if( ax25_sock != -1 )
		return ax25_sock;

	return ddp_sock;
}


// CVnetDeviceManagerLinux class implementation
//================================================
CVnetDeviceManagerLinux::CVnetDeviceManagerLinux( )
{
}

CVnetDeviceManagerLinux::~CVnetDeviceManagerLinux( )
{
}

bool CVnetDeviceManagerLinux::Detect( )
{
	int i, j, temp_socket;
	int starting_eth = 0;
	struct iwreq wrq;

	CVnetDeviceLinux *device_tmp;
	char ethname[ 100 ];

	int type;
	wxString ufname;
	bool already;

	for( j = starting_eth; j < 8; j++ )
	{
		temp_socket = open_socket();
		sprintf( ethname, "atml%d", j );
		strcpy( wrq.ifr_name, ethname );
		type = -1;
		ufname = _( "" );

		already=false;
		for(i=0; i<GetDeviceCount(); i++) {
			if(mDevices[i]->GetDevName() == wxString(ethname)) {
				already=true;
				break;
			} 
		}	

		if( ioctl( temp_socket, SIOCGIWNAME, &wrq ) < 0 )
		{
			if(already) RemoveDevice(mDevices[i]);
			continue;
		}
		if(already) continue;

		if(!memcmp(wrq.u.name,"ATMEL INTERSIL", 14))
			type = CARD_TYPE_PCMCIA;
		else if(!memcmp(wrq.u.name,"ATMEL USB503A", 13))
			type = CARD_TYPE_USB;
		else if(!memcmp(wrq.u.name,"ATMEL RFMD503", 13))
			type = CARD_TYPE_USB_RFMD;
		else if(!memcmp(wrq.u.name,"ATMEL RFMD505A", 14))
			type = CARD_TYPE_USB_505A;
		else if(!memcmp(wrq.u.name,"ATMEL MX 505A", 13))
			type = CARD_TYPE_USB_505AMX;
		else if(!memcmp(wrq.u.name,"ATMEL RFMD505", 13))
			type = CARD_TYPE_USB_505;
		else if(!memcmp(wrq.u.name,"ATMEL 2958505", 13))
			type = CARD_TYPE_USB_505_2958;
		else if(!memcmp(wrq.u.name,"ATMEL RFMD", 10))
			type = CARD_TYPE_PCMCIA_RFMD;
		else if(!memcmp(wrq.u.name,"ATMEL REVD", 10))
			type = CARD_TYPE_PCMCIA_REVD;
		else if(!memcmp(wrq.u.name,"ATMEL REVE", 10))
			type = CARD_TYPE_PCMCIA_REVE;
		else if(!memcmp(wrq.u.name,"ATMEL 504A", 10))
			type = CARD_TYPE_PCMCIA_504A;
		else if(!memcmp(wrq.u.name,"ATMEL 504", 9))
			type = CARD_TYPE_PCMCIA_504;
		else if(!memcmp(wrq.u.name,"ATMEL PCI", 9))
			type = CARD_TYPE_PCMCIA_PCI;
		else
			continue;			

		device_tmp = new CVnetDeviceLinux( temp_socket, wxString( ethname ) );

         	switch( type )
         	{
         		case CARD_TYPE_PCMCIA:
         			ufname.Append( _( "PCMCIA" ) );
         			break;
         		case CARD_TYPE_PCMCIA_RFMD:
         			ufname.Append( _( "PCMCIA RFMD" ) );
         			break;
         		case CARD_TYPE_USB:
         			ufname.Append( _( "USB" ) );
         			break;
         		case CARD_TYPE_USB_RFMD:
         			ufname.Append( _( "USB RFMD" ) );
				break;
         		case CARD_TYPE_USB_505:
         			ufname.Append( _( "RFMD 505" ) );
				break;
         		case CARD_TYPE_USB_505AMX:
         			ufname.Append( _( "Maxim 505A" ) );
				break;
         		case CARD_TYPE_USB_505A:
         			ufname.Append( _( "RFMD 505A" ) );
				break;
         		case CARD_TYPE_USB_505_2958:
         			ufname.Append( _( "2958 505" ) );
				break;
			case CARD_TYPE_PCMCIA_REVD:
				ufname.Append( _( "RFMD REVD" ) );
         			break;
			case CARD_TYPE_PCMCIA_REVE:
				ufname.Append( _( "RFMD REVE" ) );
         			break;
			case CARD_TYPE_PCMCIA_PCI:
				ufname.Append( _( "PCI" ) );
         			break;
			case CARD_TYPE_PCMCIA_504:
				ufname.Append( _( "504" ) );
         			break;
			case CARD_TYPE_PCMCIA_504A:
				ufname.Append( _( "504A" ) );
         			break;
         	}

		device_tmp->SetUFName( ufname );
		AddDevice( device_tmp );
	}

	CVnetDeviceBase *device;
	CWinterModel *model;

	for( int c = 0; c < GetDeviceCount( ); c++ )
	{
		device = GetDevice( c );
		model = device->GetModel( );

		device->GetWepInfo( ( CWepInfoData * ) model->GetChild( MC_WEPINFODATA ) );
		device->GetVersionInfo( ( CVersionInfoData * ) model->GetChild( MC_VERSIONINFODATA ) );
		device->GetStatistics( ( CStatisticsData * ) model->GetChild( MC_STATISTICSDATA ) );
		device->GetDeviceConfig( ( CDeviceConfigurationData * ) model->GetChild( MC_DEVICECONFIGURATIONDATA ) );
		device->GetMacAddress( ( CMacAddressData * ) model->GetChild( MC_MACADDRESSDATA ) );
	}

	return true;
}