cofvnet.c

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

/***************************************************************************************
	Copyright 2000-2001 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 <menu.h>
#include <signal.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/socket.h>	/* For AF_INET & struct sockaddr */

#define CALLER_COFVNET

#include "strdefs.h"
#include "vnet.h"

#undef CALLER_COFVNET

#define PCMCIA  0
#define USB	1


extern int wep_reverse;
extern WINDOW *wep_win;


int reverse;
int epilogh = 0;
int config_choices = sizeof(conf_choices) / sizeof(char *);

void init_all_pairs()
{
	init_pair(1, COLOR_RED, COLOR_BLACK);
	init_pair(2, COLOR_BLUE, COLOR_BLACK);
	init_pair(3, COLOR_YELLOW, COLOR_BLACK);
    	init_pair(4, COLOR_CYAN, COLOR_BLACK);
}

void read_ioctls_wlan(PDEVICE_CONFIGURATION pAppInfo, PENCRYPTION_INFO pEncryptionInfo,
		      int fd, char *cname)
{
	int d, utruth = 0;

	reverse = 1;
	conf_win = create_newwin(WINHEIGHT, WIDTH, 6, 0); 
	keypad(conf_win, TRUE);
	refresh();
	print_my_menu(conf_win, reverse);

	while (1) {
		d = wgetch(conf_win);
		utruth = 0;
		switch (d) {
		case KEY_UP:
			if (reverse == 1)
				reverse = config_choices;
			else
				--reverse;
			break;
		case KEY_DOWN:
			if (reverse == config_choices)
				reverse = 1;
			else
				++reverse;
			break;
		case 10:
			epilogh = reverse;
			utruth = 1;
			break;
		default:
			refresh();
			break;
		}
		print_my_menu(conf_win, reverse);
		if (d == KEY_F(1)) {	/* User did a choice come out of the infinite loop */
			wclear(conf_win);
			destroy_win(conf_win);
			break;

		}
		if (utruth == 1) {
			if (epilogh == 11) {	/* User did a choice come out of the infinite loop */
				wclear(conf_win);
				destroy_win(conf_win);
				utruth = 0;
				break;

			}


			switch (epilogh) {
			case 1:	// Set ESSID NAME
				Set_ESSID(pAppInfo, cname, fd);
				refresh();
				break;
			case 2:	// Set Channel
				Set_Channel(pAppInfo, cname, fd);
				refresh();
				break;
			case 3:	// Set Radio 
				Set_Radio(pAppInfo, cname, fd);
				refresh();
				break;
			case 4:	// Set InternationalRoaming 
				Set_InternationalRoaming(pAppInfo, cname, fd);
				refresh();
				break;
			case 5:	// Transmit Rate...
				Set_TxRate(pAppInfo, cname, fd);
				refresh();
				break;
			case 6:	// Operating Mode
				Set_OpMode(pAppInfo, cname, fd);
				refresh();
				break;
			case 7:	// Preamble Type
				Set_Preamble(pAppInfo, cname, fd);
				refresh();
				break;
			case 8:	// PowerMgmtMode Threshold
				Set_PowerMgmtMode(pAppInfo, cname, fd);
				refresh();
				break;
			case 9:	// Fragmentation Threshold
				Set_FragT(pAppInfo, cname, fd);
				refresh();
				break;
			case 10:// Rts Threshold
				Set_RtsT(pAppInfo, cname, fd);
				refresh();
				break;
			default:
				break;
			}
			utruth = 0;
		}
	}
}
int WEP_KEY_CONV(int value, PUCHAR W_KEY)
{
	WINDOW *wep_key_val;
	int coun;
	int a, b, d;
	UCHAR Get_Arg[2 * LONG_WEP_KEY_SIZE + 1], size;
	char c;
	b = 0;
	a = 0;
	size = (W_KEY[0] == 1) ? 5 : 13;
	wep_key_val = newwin(WINHEIGHT, WIDTH, 6, 0);
	box(wep_key_val, 0, 0);
	mvwhline(wep_key_val, 2, 1, ACS_HLINE, WIDTH-2);
	wattron(wep_key_val, A_BOLD);
	wattron(wep_key_val, COLOR_PAIR(2)); //CHNG
	mvwprintw(wep_key_val, 1, 18, "Give Wep Key ( %i ) value", value);
	wattroff(wep_key_val, COLOR_PAIR(2));

	CancelExit(wep_key_val, 1, 46);

	for (coun = 0; coun < size; coun++) {
		mvwprintw(wep_key_val, 3 + coun, 1,
			  "Byte %02d (two characters) \t: ", coun + 1);
		wrefresh(wep_key_val);
		for (a = 0; a < 2; a++) {
			echo();
			c = wgetch(wep_key_val);
			noecho();
			Get_Arg[a] = toupper(c);
			if ((Get_Arg[a] < 0x30) ||
			    ((Get_Arg[a] > 0x39) && (Get_Arg[a] < 0x41)) ||
			    (Get_Arg[a] > 0x46)) {
				return -1;
			}
			wrefresh(wep_key_val);
		}
		wrefresh(wep_key_val);
		W_KEY[b] = AsciiToByte(Get_Arg[0], Get_Arg[1]);
		b++;
	}
	while ((d = getch())) {
		if (d == 10) {
			wclear(wep_key_val);
			destroy_win(wep_key_val);
			print_wep_menu(wep_win, wep_reverse);
			break;
		}
	}

	wattroff(wep_key_val, A_BOLD);
	return 0;
}

UCHAR AsciiToByte(UCHAR Ascii1, UCHAR Ascii2)
{
	UCHAR digit1=0, digit2=0;

	if (Ascii1 >= 0x30 && Ascii1 <= 0x39)
		digit1 = Ascii1 - 0x30;
	else if (Ascii1 >= 0x41 && Ascii1 <= 0x46)
		digit1 = Ascii1 - 0x31 - 6;

	if (Ascii2 >= 0x30 && Ascii2 <= 0x39)
		digit2 = Ascii2 - 0x30;
	else if (Ascii2 >= 0x41 && Ascii2 <= 0x46)
		digit2 = Ascii2 - 0x31 - 6;

	return (digit1 << 4) + digit2;
}

// Wep Key Information... Details available only if a wep key is used
int Get_Wep(PENCRYPTION_INFO pEncryptionInfo, int fd, char *cname)
{
	struct iwreq wrq;
	unsigned char key[IW_ENCODING_TOKEN_MAX];

	strcpy(wrq.ifr_name, cname);

	wrq.u.data.pointer = (caddr_t) key;
	wrq.u.data.length=IW_ENCODING_TOKEN_MAX;
	wrq.u.data.flags=0;
	if(ioctl(fd, SIOCGIWENCODE, &wrq) < 0) {
		ErrorWin("Failed to Get Encryption Info");
		return -1;
	}

		pEncryptionInfo->WepKeyToUse = (wrq.u.data.flags & 0x7) -1;
		//if(pEncryptionInfo->WepKeyToUse < 0 || pEncryptionInfo->WepKeyToUse > 3) return -1;
		pEncryptionInfo->EncryptionLevel = /*wrq.u.data.length; */ (wrq.u.data.flags & IW_ENCODE_DISABLED) ? 
			0 : (wrq.u.data.length == 5 ? WEP_64BIT : WEP_128BIT ) ;
		pEncryptionInfo->AuthenticationType = (wrq.u.data.flags & IW_ENCODE_OPEN) ? C80211_MGMT_AAN_OPENSYSTEM : C80211_MGMT_AAN_SHAREDKEY;
		//pEncryptionInfo->EncryptionLevel = (wrq.u.data.length == 5) ? WEP_64BIT : WEP_128BIT;
	//	memcpy((PUCHAR)pEncryptionInfo->KeyMaterial[pEncryptionInfo->WepKeyToUse], (PUCHAR)wrq.u.data.pointer, wrq.u.data.length);
		// FIXME: also passed as reference
		if(pEncryptionInfo->EncryptionLevel)
			memcpy((PUCHAR)pEncryptionInfo->KeyMaterial[pEncryptionInfo->WepKeyToUse], (PUCHAR)wrq.u.data.pointer, wrq.u.data.length);	
	return 0;
}

int Get_Config(PDEVICE_CONFIGURATION pAppInfo, int fd, char *cname)
{
	struct iwreq wrq;

	strcpy(wrq.ifr_name, cname);
	wrq.u.data.pointer = (caddr_t) pAppInfo;
	wrq.u.data.length = 0;	//sizeof(DEVICE_CONFIGURATION);//0;
	wrq.u.data.flags = GET_SUPPORT_INFO;
	return ioctl(fd, SIOCDEVPRIVATE, &wrq);
	// OK, DEVPRIVATE
}

int Get_Stats(PSTATISTICS pStats, int fd, char *cname)
{
	struct iwreq wrq;

	strcpy(wrq.ifr_name, cname);
	wrq.u.data.pointer = (caddr_t) pStats;
	wrq.u.data.length = 0;
	wrq.u.data.flags = GET_STATISTICS;
	return ioctl(fd, SIOCDEVPRIVATE, &wrq);
	// OK, DEVPRIVATE
}

int Get_Ver(PVERSION_INFO pVersionInfo, int fd, char *cname)
{
	struct iwreq wrq;

	strcpy(wrq.ifr_name, cname);

	wrq.u.data.pointer = (caddr_t) pVersionInfo;
	wrq.u.data.length = 0;
	wrq.u.data.flags = GET_VERSION_INFO;
	return ioctl(fd, SIOCDEVPRIVATE, &wrq);
	// OK, DEVPRIVATE
}


int Get_APs(BSS_INFO_EX *AP, int fd, char *cname) 
{
	int APsFound=0, i;
  	struct iwreq wrq;
	struct iw_event * piwe;
	unsigned char buff[IW_SCAN_MAX_DATA];
	unsigned char* index=buff;

	strcpy(wrq.ifr_name, cname);

	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(fd, SIOCGIWSCAN, &wrq) && i<10; i++) sleep(1);

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


void Print_Stats(WINDOW * conf_win, PDEVICE_CONFIGURATION pAppInfo,
		 PENCRYPTION_INFO pEncryptionInfo, PSTATISTICS pStatistics)
{
	int i;
	char ch = ' ';

	HEADER( conf_win, "Current Statistics" )
  mvwprintw(conf_win, 3, 1,
		  "Successfull Transmit Packets\t: %d      ",
		  pStatistics->TxDataPacketsOk);
	mvwprintw(conf_win, 4, 1, "Error Transmit Packets\t\t: %d    ",
		  pStatistics->TxDataPacketsError);
	mvwprintw(conf_win, 5, 1,
		  "Successfully Received Packets\t: %d      ",
		  pStatistics->RxDataPacketsOk);
	mvwprintw(conf_win, 6, 1, "Error Received Packets \t: %d         ",
		  pStatistics->RxDataPacketsError);

	DisplayDriverState(conf_win, pAppInfo->StationState,
			   pAppInfo->OperatingMode, pAppInfo->MgmtErrorCode);

	if ((pAppInfo->StationState == 0x05)
	    && (pAppInfo->OperatingMode == 1)) {
		mvwprintw(conf_win, 9, 34, "BSSID : ");
		for (i = 0; i < 6; i++)
			mvwprintw(conf_win, 9, 42 + (i * 3), "%02X-",
				  pAppInfo->BSSID[i]);
		mvwprintw(conf_win, 9, 60, "\b ");
	}
	mvwprintw(conf_win, 10, 1, "Channel \t\t\t: %d",
		  pAppInfo->Channel);
	mvwprintw(conf_win, 11, 1, "SSID	\t\t\t: ");
	for (i = 0; i < pAppInfo->SSIDlength; i++)
		mvwprintw(conf_win, 11, 34 + i, "%c", pAppInfo->SSID[i]);
	for (i = pAppInfo->SSIDlength; i < 32; i++)
		mvwprintw(conf_win, 11, 34 + i, "%c", ch);

	i=pAppInfo->TxRate;
	if(i>=0 && i<=4) // Testing to avoid pointer out of range
		mvwprintw(conf_win, 12, 1, 
		  "Transmit rate	\t\t: %s", txrate[pAppInfo->TxRate]);
	i=pAppInfo->OperatingMode;
	if(i>=0 && i<=3) // Testing to avoid pointer out of range
		mvwprintw(conf_win, 13, 1, 
		  "Operating Mode\t\t\t: %s", opermode[pAppInfo->OperatingMode]);
	i=pAppInfo->RadioIsOn;
	if(i==0 || i==1) // Testing to avoid pointer out of range
		mvwprintw(conf_win, 14, 1,
		  "Radio \t\t\t\t: %s", offon[pAppInfo->RadioIsOn] );
	i=pAppInfo->PowerMgmtMode;
	if(i>=0 && i<=2) // Testing to avoid pointer out of range
		mvwprintw(conf_win, 15, 1,
		  "Power Mode\t\t\t: %s",powermode[pAppInfo->PowerMgmtMode]);
	i=pAppInfo->InternationalRoaming;
	if(i==0 || i==1) // Testing to avoid pointer out of range
		mvwprintw(conf_win, 16, 1, "International Roaming \t\t: %s",
  		  dis_enable[pAppInfo->InternationalRoaming]);
}

void Print_Wep_Stats(WINDOW * wep_win, PENCRYPTION_INFO pEncryptionInfo, PDEVICE_CONFIGURATION pAppInfo,
		     PSTATISTICS pStatistics)
{
	int i;
	UCHAR size_used = 0;
	wep_win = create_newwin(WINHEIGHT, WIDTH, 6, 0); 
	wattron(wep_win, A_BOLD);
	mvwhline(wep_win, 2, 1, ACS_HLINE, WIDTH-2); 
	wattron(wep_win, COLOR_PAIR(2));
	mvwprintw(wep_win, 1, 5, "Wep Key Information (");
	wrefresh(wep_win);
	if (pEncryptionInfo->EncryptionLevel) {
		mvwprintw(wep_win, 1, 26, "Enabled - Encryption Level %s)",
			  (pEncryptionInfo->EncryptionLevel ==
			   1) ? "64-bit" : "128-bit");
		wattroff(wep_win, COLOR_PAIR(2));
		//mvwprintw(wep_win, 4, 1, "Wep Key Used\t\t: ");
		mvwprintw(wep_win, 4, 1, "Transmission Key\t: ");
		wrefresh(wep_win);
		switch (pEncryptionInfo->WepKeyToUse) {
		case 0:
			mvwprintw(wep_win, 4, 26, "One");
			wrefresh(wep_win);
			break;
		case 1:
			mvwprintw(wep_win, 4, 26, "Two");
			wrefresh(wep_win);
			break;
		case 2:
			mvwprintw(wep_win, 4, 26, "Three");
			wrefresh(wep_win);
			break;
		case 3:
			mvwprintw(wep_win, 4, 26, "Four");
			wrefresh(wep_win);
			break;
		case 4:
			mvwprintw(wep_win, 4, 26, "None");
			wrefresh(wep_win);
			break;
		}
	} else {
		wattron(wep_win, COLOR_PAIR(1)); 
		mvwprintw(wep_win, 1, 35, "Disabled");
		wattroff(wep_win, COLOR_PAIR(1));
		wattron(wep_win, COLOR_PAIR(2));
		mvwprintw(wep_win, 1, 52, ")");
		wattroff(wep_win, COLOR_PAIR(2));
		wrefresh(wep_win);
	}
	if (pEncryptionInfo->EncryptionLevel != 0) {
		size_used =
		    (pEncryptionInfo->EncryptionLevel == 1) ? 5 : 13;
#ifndef ATMEL_WLAN
		switch (pEncryptionInfo->WepKeyToUse) {
		case 0:
			mvwprintw(wep_win, 5, 1, "Wep Key One\t\t: %02x",
				  pEncryptionInfo->WepKey1[0]);
			for (i = 1; i < size_used; i++)
				mvwprintw(wep_win, 5, 25 + (i * 3),
					  ":%02X", pEncryptionInfo->WepKey1[i]);
			mvwprintw(wep_win, 5, 41, "\b");
			wrefresh(wep_win);
			break;
		case 1:
			mvwprintw(wep_win, 5, 1, "Wep Key Two \t\t: %02x",
				  pEncryptionInfo->WepKey2[0]);
			for (i = 1; i < size_used; i++)
				mvwprintw(wep_win, 5, 25 + (i * 3),
					  ":%02X", pEncryptionInfo->WepKey2[i]);
			mvwprintw(wep_win, 5, 41, "\b");
			wrefresh(wep_win);
			break;
		case 2:
			mvwprintw(wep_win, 5, 1, "Wep Key Three\t\t: %02x",
				  pEncryptionInfo->WepKey3[0]);
			for (i = 1; i < size_used; i++)
				mvwprintw(wep_win, 5, 25 + (i * 3),
					  ":%02X", pEncryptionInfo->WepKey3[i]);
			mvwprintw(wep_win, 5, 41, "\b");
			wrefresh(wep_win);
			break;
		case 3:
			mvwprintw(wep_win, 5, 1,
				  "\tWep Key Four\t\t: %02x",
				  pEncryptionInfo->WepKey4[0]);
			for (i = 1; i < size_used; i++)
				mvwprintw(wep_win, 5, 25 + (i * 3),
					  ":%02X", pEncryptionInfo->WepKey4[i]);
			mvwprintw(wep_win, 5, 41, "\b");
			wrefresh(wep_win);
			break;
		}
#else
			//mvwprintw(wep_win, 5, 1, "Encryption Key %d\t: %02x", pEncryptionInfo->WepKeyToUse + 1,
			mvwprintw(wep_win, 5, 1, "Encryption Key \t: %02x", 
	  pEncryptionInfo->KeyMaterial[pEncryptionInfo->WepKeyToUse][0]);
			for (i = 1; i < size_used; i++)
				mvwprintw(wep_win, 5, 25 + (i * 3),
					  ":%02X", pEncryptionInfo->KeyMaterial[pEncryptionInfo->WepKeyToUse][i]);
			mvwprintw(wep_win, 5, 41, "\b");
			mvwprintw(wep_win, 5, 41, "\b");
			wrefresh(wep_win);
#endif	// !ATMEL_WLAN

#if 0		
		switch (pEncryptionInfo->WepMode) {
		case 0:
			mvwprintw(wep_win, 6, 1,
				  "Wep Mode\t\t: Optional");
			wrefresh(wep_win);
			break;
		case 1:
			mvwprintw(wep_win, 6, 1, "Wep Mode\t\t: Mandatory");
			wrefresh(wep_win);
			break;
		}
#endif
		switch (pEncryptionInfo->AuthenticationType) {
		case 0x0000:
			mvwprintw(wep_win, 6, 1,
				  "Authentication Type\t: Open System");
			wrefresh(wep_win);
			break;
		case 0x0001:
			mvwprintw(wep_win, 6, 1,
				  "Authentication Type\t: Shared Key");
			wrefresh(wep_win);
			break;
		}
		wattroff(wep_win, A_BOLD);
	}
	wattron(wep_win, A_BOLD);
	mvwhline(wep_win, 9, 1, ACS_HLINE, WIDTH-2);
	wattron(wep_win, COLOR_PAIR(1)); 
	mvwprintw(wep_win, 10, 24, "Advanced Settings");
	wrefresh(wep_win);
	wattroff(wep_win, COLOR_PAIR(1));
	mvwhline(wep_win, 11, 1, ACS_HLINE, WIDTH-2);
	wrefresh(wep_win);
	switch (pAppInfo->PreambleType) {
	case 0:
		mvwprintw(wep_win, 13, 1, "Preamble Type\t\t\t: Long");
	        wrefresh(wep_win);
		break;
	case 1:
		mvwprintw(wep_win, 13, 1, "Preamble Type\t\t\t: Short");
	wrefresh(wep_win);
		break;
	}
	if (pAppInfo->RtsCtsThreshold == 2347) {
		wattron(wep_win, COLOR_PAIR(1)); 
		mvwprintw(wep_win, 14, 44, "(Disabled)");
	wrefresh(wep_win);
		wattroff(wep_win, COLOR_PAIR(1));
	}
	mvwprintw(wep_win, 14, 1, "RtsCts Threshold \t\t: %i",
		  pAppInfo->RtsCtsThreshold);
	wrefresh(wep_win);
	if (pAppInfo->FragmentationThreshold == 2346) {
		wattron(wep_win, COLOR_PAIR(1)); 
		mvwprintw(wep_win, 15, 44, "(Disabled)");
	wrefresh(wep_win);
		wattroff(wep_win, COLOR_PAIR(1));
	}
	mvwprintw(wep_win, 15, 1, "Fragmentation Threshold\t: %i",
		  pAppInfo->FragmentationThreshold);
	wrefresh(wep_win);