d0f2cc5aea
Cc: Henk de Groot <pe1dnn@amsat.org> Cc: Randy Dunlap <randy.dunlap@oracle.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
1112 lines
39 KiB
C
1112 lines
39 KiB
C
/*******************************************************************************
|
|
* Agere Systems Inc.
|
|
* Wireless device driver for Linux (wlags49).
|
|
*
|
|
* Copyright (c) 1998-2003 Agere Systems Inc.
|
|
* All rights reserved.
|
|
* http://www.agere.com
|
|
*
|
|
* Initially developed by TriplePoint, Inc.
|
|
* http://www.triplepoint.com
|
|
*
|
|
*------------------------------------------------------------------------------
|
|
*
|
|
* This file defines routines required to parse configuration parameters
|
|
* listed in a config file, if that config file exists.
|
|
*
|
|
*------------------------------------------------------------------------------
|
|
*
|
|
* SOFTWARE LICENSE
|
|
*
|
|
* This software is provided subject to the following terms and conditions,
|
|
* which you should read carefully before using the software. Using this
|
|
* software indicates your acceptance of these terms and conditions. If you do
|
|
* not agree with these terms and conditions, do not use the software.
|
|
*
|
|
* Copyright © 2003 Agere Systems Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source or binary forms, with or without
|
|
* modifications, are permitted provided that the following conditions are met:
|
|
*
|
|
* . Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following Disclaimer as comments in the code as
|
|
* well as in the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* . Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following Disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* . Neither the name of Agere Systems Inc. nor the names of the contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* Disclaimer
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ANY
|
|
* USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
|
|
* RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
|
* DAMAGE.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/* Only include this file if USE_PROFILE is defined */
|
|
#ifdef USE_PROFILE
|
|
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
* constant definitions
|
|
******************************************************************************/
|
|
|
|
|
|
/* Allow support for calling system fcns to parse config file */
|
|
#define __KERNEL_SYSCALLS__
|
|
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
* include files
|
|
******************************************************************************/
|
|
#include <wl_version.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/unistd.h>
|
|
#include <asm/uaccess.h>
|
|
#include <limits.h>
|
|
|
|
#define BIN_DL 1
|
|
|
|
#include <debug.h>
|
|
#include <hcf.h>
|
|
//#include <hcfdef.h>
|
|
|
|
#include <wl_if.h>
|
|
#include <wl_internal.h>
|
|
#include <wl_util.h>
|
|
#include <wl_enc.h>
|
|
#include <wl_main.h>
|
|
#include <wl_profile.h>
|
|
|
|
|
|
/*******************************************************************************
|
|
* global variables
|
|
******************************************************************************/
|
|
|
|
/* Definition needed to prevent unresolved external in unistd.h */
|
|
static int errno;
|
|
|
|
#if DBG
|
|
extern p_u32 DebugFlag;
|
|
extern dbg_info_t *DbgInfo;
|
|
#endif
|
|
|
|
int parse_yes_no( char* value );
|
|
|
|
|
|
int parse_yes_no( char* value ) {
|
|
int rc = 0; //default to NO for invalid parameters
|
|
|
|
if ( strlen( value ) == 1 ) {
|
|
if ( ( value[0] | ('Y'^'y') ) == 'y' ) rc = 1;
|
|
// } else {
|
|
// this should not be debug time info, it is an enduser data entry error ;?
|
|
// DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_MICROWAVE_ROBUSTNESS );
|
|
}
|
|
return rc;
|
|
} // parse_yes_no
|
|
|
|
|
|
/*******************************************************************************
|
|
* parse_config()
|
|
*******************************************************************************
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* This function opens the device's config file and parses the options from
|
|
* it, so that it can properly configure itself. If no configuration file
|
|
* or configuration is present, then continue to use the options already
|
|
* parsed from config.opts or wireless.opts.
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
* dev - a pointer to the device's net_device structure
|
|
*
|
|
* RETURNS:
|
|
*
|
|
* N/A
|
|
*
|
|
******************************************************************************/
|
|
void parse_config( struct net_device *dev )
|
|
{
|
|
int file_desc;
|
|
#if 0 // BIN_DL
|
|
int rc;
|
|
char *cp = NULL;
|
|
#endif // BIN_DL
|
|
char buffer[MAX_LINE_SIZE];
|
|
char filename[MAX_LINE_SIZE];
|
|
mm_segment_t fs;
|
|
struct wl_private *wvlan_config = NULL;
|
|
ENCSTRCT sEncryption;
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
DBG_FUNC( "parse_config" );
|
|
DBG_ENTER( DbgInfo );
|
|
|
|
/* Get the wavelan specific info for this device */
|
|
wvlan_config = (struct wl_private *)dev->priv;
|
|
if ( wvlan_config == NULL ) {
|
|
DBG_ERROR( DbgInfo, "Wavelan specific info struct not present?\n" );
|
|
return;
|
|
}
|
|
|
|
/* setup the default encryption string */
|
|
strcpy( wvlan_config->szEncryption, DEF_CRYPT_STR );
|
|
|
|
/* Obtain a user-space process context, storing the original context */
|
|
fs = get_fs( );
|
|
set_fs( get_ds( ));
|
|
|
|
/* Determine the filename for this device and attempt to open it */
|
|
sprintf( filename, "%s%s", ROOT_CONFIG_FILENAME, dev->name );
|
|
file_desc = open( filename, O_RDONLY, 0 );
|
|
if ( file_desc != -1 ) {
|
|
DBG_TRACE( DbgInfo, "Wireless config file found. Parsing options...\n" );
|
|
|
|
/* Read out the options */
|
|
while( readline( file_desc, buffer )) {
|
|
translate_option( buffer, wvlan_config );
|
|
}
|
|
/* Close the file */
|
|
close( file_desc ); //;?even if file_desc == -1 ???
|
|
} else {
|
|
DBG_TRACE( DbgInfo, "No iwconfig file found for this device; "
|
|
"config.opts or wireless.opts will be used\n" );
|
|
}
|
|
/* Return to the original context */
|
|
set_fs( fs );
|
|
|
|
/* convert the WEP keys, if read in as key1, key2, type of data */
|
|
if ( wvlan_config->EnableEncryption ) {
|
|
memset( &sEncryption, 0, sizeof( sEncryption ));
|
|
|
|
wl_wep_decode( CRYPT_CODE, &sEncryption,
|
|
wvlan_config->szEncryption );
|
|
|
|
/* the Linux driver likes to use 1-4 for the key IDs, and then
|
|
convert to 0-3 when sending to the card. The Windows code
|
|
base used 0-3 in the API DLL, which was ported to Linux. For
|
|
the sake of the user experience, we decided to keep 0-3 as the
|
|
numbers used in the DLL; and will perform the +1 conversion here.
|
|
We could have converted the entire Linux driver, but this is
|
|
less obtrusive. This may be a "todo" to convert the whole driver */
|
|
sEncryption.wEnabled = wvlan_config->EnableEncryption;
|
|
sEncryption.wTxKeyID = wvlan_config->TransmitKeyID - 1;
|
|
|
|
memcpy( &sEncryption.EncStr, &wvlan_config->DefaultKeys,
|
|
sizeof( CFG_DEFAULT_KEYS_STRCT ));
|
|
|
|
memset( wvlan_config->szEncryption, 0, sizeof( wvlan_config->szEncryption ));
|
|
|
|
wl_wep_code( CRYPT_CODE, wvlan_config->szEncryption, &sEncryption,
|
|
sizeof( sEncryption ));
|
|
}
|
|
|
|
/* decode the encryption string for the call to wl_commit() */
|
|
wl_wep_decode( CRYPT_CODE, &sEncryption, wvlan_config->szEncryption );
|
|
|
|
wvlan_config->TransmitKeyID = sEncryption.wTxKeyID + 1;
|
|
wvlan_config->EnableEncryption = sEncryption.wEnabled;
|
|
|
|
memcpy( &wvlan_config->DefaultKeys, &sEncryption.EncStr,
|
|
sizeof( CFG_DEFAULT_KEYS_STRCT ));
|
|
|
|
#if 0 //BIN_DL
|
|
/* Obtain a user-space process context, storing the original context */
|
|
fs = get_fs( );
|
|
set_fs( get_ds( ));
|
|
|
|
//;?just to fake something
|
|
strcpy(/*wvlan_config->fw_image_*/filename, "/etc/agere/fw.bin" );
|
|
file_desc = open( /*wvlan_config->fw_image_*/filename, 0, 0 );
|
|
if ( file_desc == -1 ) {
|
|
DBG_ERROR( DbgInfo, "No image file found\n" );
|
|
} else {
|
|
DBG_TRACE( DbgInfo, "F/W image file found\n" );
|
|
#define DHF_ALLOC_SIZE 96000 //just below 96K, let's hope it suffices for now and for the future
|
|
cp = (char*)vmalloc( DHF_ALLOC_SIZE );
|
|
if ( cp == NULL ) {
|
|
DBG_ERROR( DbgInfo, "error in vmalloc\n" );
|
|
} else {
|
|
rc = read( file_desc, cp, DHF_ALLOC_SIZE );
|
|
if ( rc == DHF_ALLOC_SIZE ) {
|
|
DBG_ERROR( DbgInfo, "buffer too small, %d\n", DHF_ALLOC_SIZE );
|
|
} else if ( rc > 0 ) {
|
|
DBG_TRACE( DbgInfo, "read O.K.: %d bytes %.12s\n", rc, cp );
|
|
rc = read( file_desc, &cp[rc], 1 );
|
|
if ( rc == 0 ) {
|
|
DBG_TRACE( DbgInfo, "no more to read\n" );
|
|
}
|
|
}
|
|
if ( rc != 0 ) {
|
|
DBG_ERROR( DbgInfo, "file not read in one swoop or other error"\
|
|
", give up, too complicated, rc = %0X\n", rc );
|
|
}
|
|
vfree( cp );
|
|
}
|
|
close( file_desc );
|
|
}
|
|
set_fs( fs ); /* Return to the original context */
|
|
#endif // BIN_DL
|
|
|
|
DBG_LEAVE( DbgInfo );
|
|
return;
|
|
} // parse_config
|
|
|
|
/*******************************************************************************
|
|
* readline()
|
|
*******************************************************************************
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* This function reads in data from a given file one line at a time,
|
|
* converting the detected newline character '\n' to a null '\0'. Note that
|
|
* the file descriptor must be valid before calling this function.
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
* filedesc - the file descriptor for the open configuration file
|
|
* buffer - a buffer pointer, passed in by the caller, to which the
|
|
* line will be stored.
|
|
*
|
|
* RETURNS:
|
|
*
|
|
* the number of bytes read
|
|
* -1 on error
|
|
*
|
|
******************************************************************************/
|
|
int readline( int filedesc, char *buffer )
|
|
{
|
|
int result = -1;
|
|
int bytes_read = 0;
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
/* Make sure the file descriptor is good */
|
|
if ( filedesc != -1 ) {
|
|
/* Read in from the file byte by byte until a newline is reached */
|
|
while(( result = read( filedesc, &buffer[bytes_read], 1 )) == 1 ) {
|
|
if ( buffer[bytes_read] == '\n' ) {
|
|
buffer[bytes_read] = '\0';
|
|
bytes_read++;
|
|
break;
|
|
}
|
|
bytes_read++;
|
|
}
|
|
}
|
|
|
|
/* Return the number of bytes read */
|
|
if ( result == -1 ) {
|
|
return result;
|
|
} else {
|
|
return bytes_read;
|
|
}
|
|
} // readline
|
|
/*============================================================================*/
|
|
|
|
/*******************************************************************************
|
|
* translate_option()
|
|
*******************************************************************************
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* This function takes a line read in from the config file and parses out
|
|
* the key/value pairs. It then determines which key has been parsed and sets
|
|
* the card's configuration based on the value given.
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
* buffer - a buffer containing a line to translate
|
|
* config - a pointer to the device's private adapter structure
|
|
*
|
|
* RETURNS:
|
|
*
|
|
* N/A
|
|
*
|
|
******************************************************************************/
|
|
void translate_option( char *buffer, struct wl_private *lp )
|
|
{
|
|
unsigned int value_convert = 0;
|
|
int string_length = 0;
|
|
char *key = NULL;
|
|
char *value = NULL;
|
|
u_char mac_value[ETH_ALEN];
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
DBG_FUNC( "translate_option" );
|
|
|
|
if ( buffer == NULL || lp == NULL ) {
|
|
DBG_ERROR( DbgInfo, "Config file buffer and/or wavelan buffer ptr NULL\n" );
|
|
return;
|
|
}
|
|
|
|
ParseConfigLine( buffer, &key, &value );
|
|
|
|
if ( key == NULL || value == NULL ) {
|
|
return;
|
|
}
|
|
|
|
/* Determine which key it is and perform the appropriate action */
|
|
|
|
/* Configuration parameters used in all scenarios */
|
|
#if DBG
|
|
/* handle DebugFlag as early as possible so it starts its influence as early
|
|
* as possible
|
|
*/
|
|
if ( strcmp( key, PARM_NAME_DEBUG_FLAG ) == 0 ) {
|
|
if ( DebugFlag == ~0 ) { //if DebugFlag is not specified on the command line
|
|
if ( DbgInfo->DebugFlag == 0 ) { /* if pc_debug did not set DebugFlag (i.e.pc_debug is
|
|
* not specified or specified outside the 4-8 range
|
|
*/
|
|
DbgInfo->DebugFlag |= DBG_DEFAULTS;
|
|
}
|
|
} else {
|
|
DbgInfo->DebugFlag = wl_atoi( value ); //;?DebugFlag;
|
|
}
|
|
DbgInfo->DebugFlag = wl_atoi( value ); //;?Delete ASAP
|
|
}
|
|
#endif /* DBG */
|
|
if ( strcmp( key, PARM_NAME_AUTH_KEY_MGMT_SUITE ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_AUTH_KEY_MGMT_SUITE, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_AUTH_KEY_MGMT_SUITE ) || ( value_convert <= PARM_MAX_AUTH_KEY_MGMT_SUITE )) {
|
|
lp->AuthKeyMgmtSuite = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_AUTH_KEY_MGMT_SUITE );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_BRSC_2GHZ ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_BRSC_2GHZ, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_BRSC ) || ( value_convert <= PARM_MAX_BRSC )) {
|
|
lp->brsc[0] = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invaid; will be ignored\n", PARM_NAME_BRSC_2GHZ );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_BRSC_5GHZ ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_BRSC_5GHZ, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_BRSC ) || ( value_convert <= PARM_MAX_BRSC )) {
|
|
lp->brsc[1] = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invaid; will be ignored\n", PARM_NAME_BRSC_5GHZ );
|
|
}
|
|
}
|
|
else if (( strcmp( key, PARM_NAME_DESIRED_SSID ) == 0 ) || ( strcmp( key, PARM_NAME_OWN_SSID ) == 0 )) {
|
|
DBG_TRACE( DbgInfo, "SSID, value: %s\n", value );
|
|
|
|
memset( lp->NetworkName, 0, ( PARM_MAX_NAME_LEN + 1 ));
|
|
|
|
/* Make sure the value isn't too long */
|
|
string_length = strlen( value );
|
|
if ( string_length > PARM_MAX_NAME_LEN ) {
|
|
DBG_WARNING( DbgInfo, "SSID too long; will be truncated\n" );
|
|
string_length = PARM_MAX_NAME_LEN;
|
|
}
|
|
|
|
memcpy( lp->NetworkName, value, string_length );
|
|
}
|
|
#if 0
|
|
else if ( strcmp( key, PARM_NAME_DOWNLOAD_FIRMWARE ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "DOWNLOAD_FIRMWARE, value: %s\n", value );
|
|
memset( lp->fw_image_filename, 0, ( MAX_LINE_SIZE + 1 ));
|
|
/* Make sure the value isn't too long */
|
|
string_length = strlen( value );
|
|
if ( string_length > MAX_LINE_SIZE ) {
|
|
DBG_WARNING( DbgInfo, "F/W image file name too long; will be ignored\n" );
|
|
} else {
|
|
memcpy( lp->fw_image_filename, value, string_length );
|
|
}
|
|
}
|
|
#endif
|
|
else if ( strcmp( key, PARM_NAME_ENABLE_ENCRYPTION ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_ENABLE_ENCRYPTION, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_ENABLE_ENCRYPTION ) && ( value_convert <= PARM_MAX_ENABLE_ENCRYPTION )) {
|
|
lp->EnableEncryption = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_ENABLE_ENCRYPTION );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_ENCRYPTION ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_ENCRYPTION, value );
|
|
|
|
memset( lp->szEncryption, 0, sizeof( lp->szEncryption ));
|
|
|
|
/* Make sure the value isn't too long */
|
|
string_length = strlen( value );
|
|
if ( string_length > sizeof( lp->szEncryption ) ) {
|
|
DBG_WARNING( DbgInfo, "%s too long; will be truncated\n", PARM_NAME_ENCRYPTION );
|
|
string_length = sizeof( lp->szEncryption );
|
|
}
|
|
|
|
memcpy( lp->szEncryption, value, string_length );
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_KEY1 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_KEY1, value );
|
|
|
|
if ( is_valid_key_string( value )) {
|
|
memset( lp->DefaultKeys.key[0].key, 0, MAX_KEY_SIZE );
|
|
|
|
key_string2key( value, &lp->DefaultKeys.key[0] );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_KEY1 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_KEY2 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_KEY2, value );
|
|
|
|
if ( is_valid_key_string( value )) {
|
|
memset( lp->DefaultKeys.key[1].key, 0, MAX_KEY_SIZE );
|
|
|
|
key_string2key( value, &lp->DefaultKeys.key[1] );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_KEY2 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_KEY3 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_KEY3, value );
|
|
|
|
if ( is_valid_key_string( value )) {
|
|
memset( lp->DefaultKeys.key[2].key, 0, MAX_KEY_SIZE );
|
|
|
|
key_string2key( value, &lp->DefaultKeys.key[2] );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_KEY3 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_KEY4 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_KEY4, value );
|
|
|
|
if ( is_valid_key_string( value )) {
|
|
memset( lp->DefaultKeys.key[3].key, 0, MAX_KEY_SIZE );
|
|
|
|
key_string2key( value, &lp->DefaultKeys.key[3] );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_KEY4 );
|
|
}
|
|
}
|
|
/* New Parameters for WARP */
|
|
else if ( strcmp( key, PARM_NAME_LOAD_BALANCING ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_LOAD_BALANCING, value );
|
|
lp->loadBalancing = parse_yes_no(value);
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_MEDIUM_DISTRIBUTION ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_MEDIUM_DISTRIBUTION, value );
|
|
lp->mediumDistribution = parse_yes_no(value);
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_MICROWAVE_ROBUSTNESS) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_MICROWAVE_ROBUSTNESS, value );
|
|
lp->MicrowaveRobustness = parse_yes_no(value);
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_MULTICAST_RATE ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_MULTICAST_RATE, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
|
|
if (( value_convert >= PARM_MIN_MULTICAST_RATE ) && ( value_convert <= PARM_MAX_MULTICAST_RATE )) {
|
|
lp->MulticastRate[0] = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_MULTICAST_RATE );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_OWN_CHANNEL ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_OWN_CHANNEL, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if ( wl_is_a_valid_chan( value_convert )) {
|
|
if ( value_convert > 14 ) {
|
|
value_convert = value_convert | 0x100;
|
|
}
|
|
lp->Channel = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_OWN_CHANNEL );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_OWN_NAME ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_OWN_NAME, value );
|
|
|
|
memset( lp->StationName, 0, ( PARM_MAX_NAME_LEN + 1 ));
|
|
|
|
/* Make sure the value isn't too long */
|
|
string_length = strlen( value );
|
|
if ( string_length > PARM_MAX_NAME_LEN ) {
|
|
DBG_WARNING( DbgInfo, "%s too long; will be truncated\n", PARM_NAME_OWN_NAME );
|
|
string_length = PARM_MAX_NAME_LEN;
|
|
}
|
|
|
|
memcpy( lp->StationName, value, string_length );
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_RTS_THRESHOLD ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_RTS_THRESHOLD ) && ( value_convert <= PARM_MAX_RTS_THRESHOLD )) {
|
|
lp->RTSThreshold = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_SRSC_2GHZ ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_SRSC_2GHZ, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_SRSC ) || ( value_convert <= PARM_MAX_SRSC )) {
|
|
lp->srsc[0] = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invaid; will be ignored\n", PARM_NAME_SRSC_2GHZ );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_SRSC_5GHZ ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_SRSC_5GHZ, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_SRSC ) || ( value_convert <= PARM_MAX_SRSC )) {
|
|
lp->srsc[1] = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invaid; will be ignored\n", PARM_NAME_SRSC_5GHZ );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_SYSTEM_SCALE ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_SYSTEM_SCALE, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_SYSTEM_SCALE ) && ( value_convert <= PARM_MAX_SYSTEM_SCALE )) {
|
|
lp->DistanceBetweenAPs = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_SYSTEM_SCALE );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_TX_KEY ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_TX_KEY, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_TX_KEY ) && ( value_convert <= PARM_MAX_TX_KEY )) {
|
|
lp->TransmitKeyID = wl_atoi( value );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_KEY );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_TX_RATE ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_TX_RATE ) && ( value_convert <= PARM_MAX_TX_RATE )) {
|
|
lp->TxRateControl[0] = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_TX_POW_LEVEL ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_TX_POW_LEVEL, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_TX_POW_LEVEL ) || ( value_convert <= PARM_MAX_TX_POW_LEVEL )) {
|
|
lp->txPowLevel = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_POW_LEVEL );
|
|
}
|
|
}
|
|
|
|
/* Need to add? : Country code, Short/Long retry */
|
|
|
|
/* Configuration parameters specific to STA mode */
|
|
#if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
|
|
//;?seems reasonable that even an AP-only driver could afford this small additional footprint
|
|
if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA ) {
|
|
//;?should we return an error status in AP mode
|
|
if ( strcmp( key, PARM_NAME_PORT_TYPE ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_PORT_TYPE, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert == PARM_MIN_PORT_TYPE ) || ( value_convert == PARM_MAX_PORT_TYPE )) {
|
|
lp->PortType = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_PORT_TYPE );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_PM_ENABLED ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_PM_ENABLED, value );
|
|
value_convert = wl_atoi( value );
|
|
/* ;? how about wl_main.c containing
|
|
* VALID_PARAM( PARM_PM_ENABLED <= WVLAN_PM_STATE_STANDARD ||
|
|
* ( PARM_PM_ENABLED & 0x7FFF ) <= WVLAN_PM_STATE_STANDARD );
|
|
*/
|
|
if ( ( value_convert & 0x7FFF ) <= PARM_MAX_PM_ENABLED) {
|
|
lp->PMEnabled = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_PM_ENABLED );
|
|
//;?this is a data entry error, hence not a DBG_WARNING
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_CREATE_IBSS ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_CREATE_IBSS, value );
|
|
lp->CreateIBSS = parse_yes_no(value);
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_MULTICAST_RX ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_MULTICAST_RX, value );
|
|
lp->MulticastReceive = parse_yes_no(value);
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_MAX_SLEEP ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_MAX_SLEEP, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= 0 ) && ( value_convert <= 65535 )) {
|
|
lp->MaxSleepDuration = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_MAX_SLEEP );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_NETWORK_ADDR ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_NETWORK_ADDR, value );
|
|
|
|
if ( parse_mac_address( value, mac_value ) == ETH_ALEN ) {
|
|
memcpy( lp->MACAddress, mac_value, ETH_ALEN );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_NETWORK_ADDR );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_AUTHENTICATION ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_AUTHENTICATION, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_AUTHENTICATION ) && ( value_convert <= PARM_MAX_AUTHENTICATION )) {
|
|
lp->authentication = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_AUTHENTICATION );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_OWN_ATIM_WINDOW ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_OWN_ATIM_WINDOW, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_OWN_ATIM_WINDOW ) && ( value_convert <= PARM_MAX_OWN_ATIM_WINDOW )) {
|
|
lp->atimWindow = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_OWN_ATIM_WINDOW );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_PM_HOLDOVER_DURATION ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_PM_HOLDOVER_DURATION, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_PM_HOLDOVER_DURATION ) && ( value_convert <= PARM_MAX_PM_HOLDOVER_DURATION )) {
|
|
lp->holdoverDuration = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_PM_HOLDOVER_DURATION );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_PROMISCUOUS_MODE ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_PROMISCUOUS_MODE, value );
|
|
lp->promiscuousMode = parse_yes_no(value);
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_CONNECTION_CONTROL ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_CONNECTION_CONTROL, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_CONNECTION_CONTROL ) && ( value_convert <= PARM_MAX_CONNECTION_CONTROL )) {
|
|
lp->connectionControl = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_CONNECTION_CONTROL );
|
|
}
|
|
}
|
|
|
|
/* Need to add? : Probe Data Rate */
|
|
}
|
|
#endif /* (HCF_TYPE) & HCF_TYPE_STA */
|
|
|
|
/* Configuration parameters specific to AP mode */
|
|
#if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
|
|
//;?should we restore this to allow smaller memory footprint
|
|
if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
|
|
if ( strcmp( key, PARM_NAME_OWN_DTIM_PERIOD ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_OWN_DTIM_PERIOD, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if ( value_convert >= PARM_MIN_OWN_DTIM_PERIOD ) {
|
|
lp->DTIMPeriod = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_OWN_DTIM_PERIOD );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_REJECT_ANY ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_REJECT_ANY, value );
|
|
lp->RejectAny = parse_yes_no(value);
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_EXCLUDE_UNENCRYPTED ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_EXCLUDE_UNENCRYPTED, value );
|
|
lp->ExcludeUnencrypted = parse_yes_no(value);
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_MULTICAST_PM_BUFFERING ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_MULTICAST_PM_BUFFERING, value );
|
|
lp->ExcludeUnencrypted = parse_yes_no(value);
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_INTRA_BSS_RELAY ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_INTRA_BSS_RELAY, value );
|
|
lp->ExcludeUnencrypted = parse_yes_no(value);
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_OWN_BEACON_INTERVAL ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_OWN_BEACON_INTERVAL, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if ( value_convert >= PARM_MIN_OWN_BEACON_INTERVAL ) {
|
|
lp->ownBeaconInterval = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_OWN_BEACON_INTERVAL );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_COEXISTENCE ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_COEXISTENCE, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if ( value_convert >= PARM_MIN_COEXISTENCE ) {
|
|
lp->coexistence = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_COEXISTENCE );
|
|
}
|
|
}
|
|
|
|
#ifdef USE_WDS
|
|
else if ( strcmp( key, PARM_NAME_RTS_THRESHOLD1 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD1, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_RTS_THRESHOLD ) && ( value_convert <= PARM_MAX_RTS_THRESHOLD )) {
|
|
lp->wds_port[0].rtsThreshold = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD1 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_RTS_THRESHOLD2 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD2, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_RTS_THRESHOLD ) && ( value_convert <= PARM_MAX_RTS_THRESHOLD )) {
|
|
lp->wds_port[1].rtsThreshold = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD2 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_RTS_THRESHOLD3 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD3, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_RTS_THRESHOLD ) && ( value_convert <= PARM_MAX_RTS_THRESHOLD )) {
|
|
lp->wds_port[2].rtsThreshold = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD3 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_RTS_THRESHOLD4 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD4, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_RTS_THRESHOLD ) && ( value_convert <= PARM_MAX_RTS_THRESHOLD )) {
|
|
lp->wds_port[3].rtsThreshold = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD4 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_RTS_THRESHOLD5 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD5, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_RTS_THRESHOLD ) && ( value_convert <= PARM_MAX_RTS_THRESHOLD )) {
|
|
lp->wds_port[4].rtsThreshold = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD5 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_RTS_THRESHOLD6 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD6, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_RTS_THRESHOLD ) && ( value_convert <= PARM_MAX_RTS_THRESHOLD )) {
|
|
lp->wds_port[5].rtsThreshold = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD6 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_TX_RATE1 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE1, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_TX_RATE ) && ( value_convert <= PARM_MAX_TX_RATE )) {
|
|
lp->wds_port[0].txRateCntl = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE1 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_TX_RATE2 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE2, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_TX_RATE ) && ( value_convert <= PARM_MAX_TX_RATE )) {
|
|
lp->wds_port[1].txRateCntl = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE2 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_TX_RATE3 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE3, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_TX_RATE ) && ( value_convert <= PARM_MAX_TX_RATE )) {
|
|
lp->wds_port[2].txRateCntl = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE3 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_TX_RATE4 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE4, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_TX_RATE ) && ( value_convert <= PARM_MAX_TX_RATE )) {
|
|
lp->wds_port[3].txRateCntl = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE4 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_TX_RATE5 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE5, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_TX_RATE ) && ( value_convert <= PARM_MAX_TX_RATE )) {
|
|
lp->wds_port[4].txRateCntl = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE5 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_TX_RATE6 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE6, value );
|
|
|
|
value_convert = wl_atoi( value );
|
|
if (( value_convert >= PARM_MIN_TX_RATE ) && ( value_convert <= PARM_MAX_TX_RATE )) {
|
|
lp->wds_port[5].txRateCntl = value_convert;
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE6 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_WDS_ADDRESS1 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS1, value );
|
|
|
|
if ( parse_mac_address( value, mac_value ) == ETH_ALEN ) {
|
|
memcpy( lp->wds_port[0].wdsAddress, mac_value, ETH_ALEN );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS1 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_WDS_ADDRESS2 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS2, value );
|
|
|
|
if ( parse_mac_address( value, mac_value ) == ETH_ALEN ) {
|
|
memcpy( lp->wds_port[1].wdsAddress, mac_value, ETH_ALEN );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS2 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_WDS_ADDRESS3 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS3, value );
|
|
|
|
if ( parse_mac_address( value, mac_value ) == ETH_ALEN ) {
|
|
memcpy( lp->wds_port[2].wdsAddress, mac_value, ETH_ALEN );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS3 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_WDS_ADDRESS4 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS4, value );
|
|
|
|
if ( parse_mac_address( value, mac_value ) == ETH_ALEN ) {
|
|
memcpy( lp->wds_port[3].wdsAddress, mac_value, ETH_ALEN );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS4 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_WDS_ADDRESS5 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS5, value );
|
|
|
|
if ( parse_mac_address( value, mac_value ) == ETH_ALEN ) {
|
|
memcpy( lp->wds_port[4].wdsAddress, mac_value, ETH_ALEN );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS5 );
|
|
}
|
|
}
|
|
else if ( strcmp( key, PARM_NAME_WDS_ADDRESS6 ) == 0 ) {
|
|
DBG_TRACE( DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS6, value );
|
|
|
|
if ( parse_mac_address( value, mac_value ) == ETH_ALEN ) {
|
|
memcpy( lp->wds_port[5].wdsAddress, mac_value, ETH_ALEN );
|
|
} else {
|
|
DBG_WARNING( DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS6 );
|
|
}
|
|
}
|
|
#endif /* USE_WDS */
|
|
}
|
|
#endif /* (HCF_TYPE) & HCF_TYPE_AP */
|
|
|
|
return;
|
|
} // translate_option
|
|
/*============================================================================*/
|
|
|
|
/*******************************************************************************
|
|
* parse_mac_address()
|
|
*******************************************************************************
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* This function will parse a mac address string and convert it to a byte
|
|
* array.
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
* value - the MAC address, represented as a string
|
|
* byte_array - the MAC address, represented as a byte array of length
|
|
* ETH_ALEN
|
|
*
|
|
* RETURNS:
|
|
*
|
|
* The number of bytes in the final MAC address, should equal to ETH_ALEN.
|
|
*
|
|
******************************************************************************/
|
|
int parse_mac_address( char *value, u_char *byte_array )
|
|
{
|
|
int value_offset = 0;
|
|
int array_offset = 0;
|
|
int field_offset = 0;
|
|
char byte_field[3];
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
memset( byte_field, '\0', 3 );
|
|
|
|
while( value[value_offset] != '\0' ) {
|
|
/* Skip over the colon chars seperating the bytes, if they exist */
|
|
if ( value[value_offset] == ':' ) {
|
|
value_offset++;
|
|
continue;
|
|
}
|
|
|
|
byte_field[field_offset] = value[value_offset];
|
|
field_offset++;
|
|
value_offset++;
|
|
|
|
/* Once the byte_field is filled, convert it and store it */
|
|
if ( field_offset == 2 ) {
|
|
byte_field[field_offset] = '\0';
|
|
byte_array[array_offset] = simple_strtoul( byte_field, NULL, 16 );
|
|
field_offset = 0;
|
|
array_offset++;
|
|
}
|
|
}
|
|
|
|
/* Use the array_offset as a check; 6 bytes should be written to the
|
|
byte_array */
|
|
return array_offset;
|
|
} // parse_mac_address
|
|
/*============================================================================*/
|
|
|
|
/*******************************************************************************
|
|
* ParseConfigLine()
|
|
*******************************************************************************
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* Parses a line from the configuration file into an L-val and an R-val,
|
|
* representing a key/value pair.
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
* pszLine - the line from the config file to parse
|
|
* ppszLVal - the resulting L-val (Key)
|
|
* ppszRVal - the resulting R-val (Value)
|
|
*
|
|
* RETURNS:
|
|
*
|
|
* N/A
|
|
*
|
|
******************************************************************************/
|
|
void ParseConfigLine( char *pszLine, char **ppszLVal, char **ppszRVal )
|
|
{
|
|
int i;
|
|
int size;
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
DBG_FUNC( "ParseConfigLine" );
|
|
DBG_ENTER( DbgInfo );
|
|
|
|
/* get a snapshot of our string size */
|
|
size = strlen( pszLine );
|
|
*ppszLVal = NULL;
|
|
*ppszRVal = NULL;
|
|
|
|
if ( pszLine[0] != '#' && /* skip the line if it is a comment */
|
|
pszLine[0] != '\n'&& /* if it's an empty UNIX line, do nothing */
|
|
!( pszLine[0] == '\r' && pszLine[1] == '\n' ) /* if it's an empty MS-DOS line, do nothing */
|
|
) {
|
|
/* advance past any whitespace, and assign the L-value */
|
|
for( i = 0; i < size; i++ ) {
|
|
if ( pszLine[i] != ' ' ) {
|
|
*ppszLVal = &pszLine[i];
|
|
break;
|
|
}
|
|
}
|
|
/* advance to the end of the l-value*/
|
|
for( i++; i < size; i++ ) {
|
|
if ( pszLine[i] == ' ' || pszLine[i] == '=' ) {
|
|
pszLine[i] = '\0';
|
|
break;
|
|
}
|
|
}
|
|
/* make any whitespace and the equal sign a NULL character, and
|
|
advance to the R-Value */
|
|
for( i++; i < size; i++ ) {
|
|
if ( pszLine[i] == ' ' || pszLine[i] == '=' ) {
|
|
pszLine[i] = '\0';
|
|
continue;
|
|
}
|
|
*ppszRVal = &pszLine[i];
|
|
break;
|
|
}
|
|
/* make the line ending character(s) a NULL */
|
|
for( i++; i < size; i++ ) {
|
|
if ( pszLine[i] == '\n' ) {
|
|
pszLine[i] = '\0';
|
|
}
|
|
if (( pszLine[i] == '\r' ) && ( pszLine[i+1] == '\n' )) {
|
|
pszLine[i] = '\0';
|
|
}
|
|
}
|
|
}
|
|
DBG_LEAVE( DbgInfo );
|
|
} // ParseConfigLine
|
|
/*============================================================================*/
|
|
|
|
#endif // USE_PROFILE
|