PageRenderTime 73ms CodeModel.GetById 23ms app.highlight 43ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/staging/wlags49_h2/wl_profile.c

https://bitbucket.org/wisechild/galaxy-nexus
C | 1012 lines | 641 code | 129 blank | 242 comment | 359 complexity | a7e8b6ed4c5cc9c0720bf1ef91819aef MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
   1/*******************************************************************************
   2 * Agere Systems Inc.
   3 * Wireless device driver for Linux (wlags49).
   4 *
   5 * Copyright (c) 1998-2003 Agere Systems Inc.
   6 * All rights reserved.
   7 *   http://www.agere.com
   8 *
   9 * Initially developed by TriplePoint, Inc.
  10 *   http://www.triplepoint.com
  11 *
  12 *------------------------------------------------------------------------------
  13 *
  14 *   This file defines routines required to parse configuration parameters
  15 *   listed in a config file, if that config file exists.
  16 *
  17 *------------------------------------------------------------------------------
  18 *
  19 * SOFTWARE LICENSE
  20 *
  21 * This software is provided subject to the following terms and conditions,
  22 * which you should read carefully before using the software.  Using this
  23 * software indicates your acceptance of these terms and conditions.  If you do
  24 * not agree with these terms and conditions, do not use the software.
  25 *
  26 * Copyright © 2003 Agere Systems Inc.
  27 * All rights reserved.
  28 *
  29 * Redistribution and use in source or binary forms, with or without
  30 * modifications, are permitted provided that the following conditions are met:
  31 *
  32 * . Redistributions of source code must retain the above copyright notice, this
  33 *    list of conditions and the following Disclaimer as comments in the code as
  34 *    well as in the documentation and/or other materials provided with the
  35 *    distribution.
  36 *
  37 * . Redistributions in binary form must reproduce the above copyright notice,
  38 *    this list of conditions and the following Disclaimer in the documentation
  39 *    and/or other materials provided with the distribution.
  40 *
  41 * . Neither the name of Agere Systems Inc. nor the names of the contributors
  42 *    may be used to endorse or promote products derived from this software
  43 *    without specific prior written permission.
  44 *
  45 * Disclaimer
  46 *
  47 * THIS SOFTWARE IS PROVIDED “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES,
  48 * INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
  49 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  ANY
  50 * USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
  51 * RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
  52 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  53 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  54 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  55 * ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
  56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  57 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  58 * DAMAGE.
  59 *
  60 ******************************************************************************/
  61
  62/* Only include this file if USE_PROFILE is defined */
  63#ifdef USE_PROFILE
  64
  65
  66
  67
  68/*******************************************************************************
  69 *  constant definitions
  70 ******************************************************************************/
  71
  72
  73/* Allow support for calling system fcns to parse config file */
  74#define __KERNEL_SYSCALLS__
  75
  76
  77
  78
  79/*******************************************************************************
  80 * include files
  81 ******************************************************************************/
  82#include <wl_version.h>
  83
  84#include <linux/netdevice.h>
  85#include <linux/etherdevice.h>
  86#include <linux/unistd.h>
  87#include <asm/uaccess.h>
  88#include <limits.h>
  89
  90#define BIN_DL 1
  91
  92#include <debug.h>
  93#include <hcf.h>
  94/* #include <hcfdef.h> */
  95
  96#include <wl_if.h>
  97#include <wl_internal.h>
  98#include <wl_util.h>
  99#include <wl_enc.h>
 100#include <wl_main.h>
 101#include <wl_profile.h>
 102
 103
 104/*******************************************************************************
 105 * global variables
 106 ******************************************************************************/
 107
 108/* Definition needed to prevent unresolved external in unistd.h */
 109static int errno;
 110
 111#if DBG
 112extern p_u32    DebugFlag;
 113extern dbg_info_t *DbgInfo;
 114#endif
 115
 116int parse_yes_no(char *value);
 117
 118
 119int parse_yes_no(char *value)
 120{
 121int rc = 0;										/* default to NO for invalid parameters */
 122
 123	if (strlen(value) == 1) {
 124		if ((value[0] | ('Y'^'y')) == 'y')
 125			rc = 1;
 126	/* } else { */
 127		/* this should not be debug time info, it is an enduser data entry error ;? */
 128		/* DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_MICROWAVE_ROBUSTNESS); */
 129	}
 130	return rc;
 131} /* parse_yes_no */
 132
 133
 134/*******************************************************************************
 135 *	parse_config()
 136 *******************************************************************************
 137 *
 138 *  DESCRIPTION:
 139 *
 140 *      This function opens the device's config file and parses the options from
 141 *   it, so that it can properly configure itself. If no configuration file
 142 *   or configuration is present, then continue to use the options already
 143 *   parsed from config.opts or wireless.opts.
 144 *
 145 *  PARAMETERS:
 146 *
 147 *      dev - a pointer to the device's net_device structure
 148 *
 149 *  RETURNS:
 150 *
 151 *      N/A
 152 *
 153 ******************************************************************************/
 154void parse_config(struct net_device *dev)
 155{
 156	int				    file_desc;
 157#if 0 /* BIN_DL */
 158	int				rc;
 159	char				*cp = NULL;
 160#endif /* BIN_DL */
 161	char                buffer[MAX_LINE_SIZE];
 162	char                filename[MAX_LINE_SIZE];
 163	mm_segment_t	    fs;
 164	struct wl_private   *wvlan_config = NULL;
 165	ENCSTRCT            sEncryption;
 166	/*------------------------------------------------------------------------*/
 167
 168	DBG_FUNC("parse_config");
 169	DBG_ENTER(DbgInfo);
 170
 171	/* Get the wavelan specific info for this device */
 172	wvlan_config = dev->priv;
 173	if (wvlan_config == NULL) {
 174		DBG_ERROR(DbgInfo, "Wavelan specific info struct not present?\n");
 175		return;
 176	}
 177
 178	/* setup the default encryption string */
 179	strcpy(wvlan_config->szEncryption, DEF_CRYPT_STR);
 180
 181	/* Obtain a user-space process context, storing the original context */
 182	fs = get_fs();
 183	set_fs(get_ds());
 184
 185	/* Determine the filename for this device and attempt to open it */
 186	sprintf(filename, "%s%s", ROOT_CONFIG_FILENAME, dev->name);
 187	file_desc = open(filename, O_RDONLY, 0);
 188	if (file_desc != -1) {
 189		DBG_TRACE(DbgInfo, "Wireless config file found. Parsing options...\n");
 190
 191		/* Read out the options */
 192		while (readline(file_desc, buffer))
 193			translate_option(buffer, wvlan_config);
 194		/* Close the file */
 195		close(file_desc);	/* ;?even if file_desc == -1 ??? */
 196	} else {
 197		DBG_TRACE(DbgInfo, "No iwconfig file found for this device; "
 198				   "config.opts or wireless.opts will be used\n");
 199	}
 200	/* Return to the original context */
 201	set_fs(fs);
 202
 203	/* convert the WEP keys, if read in as key1, key2, type of data */
 204	if (wvlan_config->EnableEncryption) {
 205		memset(&sEncryption, 0, sizeof(sEncryption));
 206
 207		wl_wep_decode(CRYPT_CODE, &sEncryption,
 208						   wvlan_config->szEncryption);
 209
 210		/* the Linux driver likes to use 1-4 for the key IDs, and then
 211		   convert to 0-3 when sending to the card.  The Windows code
 212		   base used 0-3 in the API DLL, which was ported to Linux.  For
 213		   the sake of the user experience, we decided to keep 0-3 as the
 214		   numbers used in the DLL; and will perform the +1 conversion here.
 215		   We could have converted  the entire Linux driver, but this is
 216		   less obtrusive.  This may be a "todo" to convert the whole driver */
 217		sEncryption.wEnabled = wvlan_config->EnableEncryption;
 218		sEncryption.wTxKeyID = wvlan_config->TransmitKeyID - 1;
 219
 220		memcpy(&sEncryption.EncStr, &wvlan_config->DefaultKeys,
 221				sizeof(CFG_DEFAULT_KEYS_STRCT));
 222
 223		memset(wvlan_config->szEncryption, 0, sizeof(wvlan_config->szEncryption));
 224
 225		wl_wep_code(CRYPT_CODE, wvlan_config->szEncryption, &sEncryption,
 226						 sizeof(sEncryption));
 227	}
 228
 229	/* decode the encryption string for the call to wl_commit() */
 230	wl_wep_decode(CRYPT_CODE, &sEncryption, wvlan_config->szEncryption);
 231
 232	wvlan_config->TransmitKeyID    = sEncryption.wTxKeyID + 1;
 233	wvlan_config->EnableEncryption = sEncryption.wEnabled;
 234
 235	memcpy(&wvlan_config->DefaultKeys, &sEncryption.EncStr,
 236			sizeof(CFG_DEFAULT_KEYS_STRCT));
 237
 238#if 0 /* BIN_DL */
 239		/* Obtain a user-space process context, storing the original context */
 240		fs = get_fs();
 241		set_fs(get_ds());
 242
 243		/* ;?just to fake something */
 244		strcpy(/*wvlan_config->fw_image_*/filename, "/etc/agere/fw.bin");
 245		file_desc = open(/*wvlan_config->fw_image_*/filename, 0, 0);
 246		if (file_desc == -1) {
 247			DBG_ERROR(DbgInfo, "No image file found\n");
 248		} else {
 249			DBG_TRACE(DbgInfo, "F/W image file found\n");
 250#define DHF_ALLOC_SIZE 96000			/* just below 96K, let's hope it suffices for now and for the future */
 251			cp = vmalloc(DHF_ALLOC_SIZE);
 252			if (cp == NULL) {
 253				DBG_ERROR(DbgInfo, "error in vmalloc\n");
 254			} else {
 255				rc = read(file_desc, cp, DHF_ALLOC_SIZE);
 256				if (rc == DHF_ALLOC_SIZE) {
 257					DBG_ERROR(DbgInfo, "buffer too small, %d\n", DHF_ALLOC_SIZE);
 258				} else if (rc > 0) {
 259					DBG_TRACE(DbgInfo, "read O.K.: %d bytes  %.12s\n", rc, cp);
 260					rc = read(file_desc, &cp[rc], 1);
 261					if (rc == 0)
 262						DBG_TRACE(DbgInfo, "no more to read\n");
 263				}
 264				if (rc != 0) {
 265					DBG_ERROR(DbgInfo, "file not read in one swoop or other error"\
 266										", give up, too complicated, rc = %0X\n", rc);
 267				}
 268				vfree(cp);
 269			}
 270			close(file_desc);
 271		}
 272		set_fs(fs);			/* Return to the original context */
 273#endif /* BIN_DL */
 274
 275	DBG_LEAVE(DbgInfo);
 276	return;
 277} /* parse_config */
 278
 279/*******************************************************************************
 280 *	readline()
 281 *******************************************************************************
 282 *
 283 *  DESCRIPTION:
 284 *
 285 *      This function reads in data from a given file one line at a time,
 286 *   converting the detected newline character '\n' to a null '\0'. Note that
 287 *   the file descriptor must be valid before calling this function.
 288 *
 289 *  PARAMETERS:
 290 *
 291 *      filedesc    - the file descriptor for the open configuration file
 292 *      buffer      - a buffer pointer, passed in by the caller, to which the
 293 *                    line will be stored.
 294 *
 295 *  RETURNS:
 296 *
 297 *      the number of bytes read
 298 *      -1 on error
 299 *
 300 ******************************************************************************/
 301int readline(int filedesc, char *buffer)
 302{
 303	int result = -1;
 304	int bytes_read = 0;
 305	/*------------------------------------------------------------------------*/
 306
 307	/* Make sure the file descriptor is good */
 308	if (filedesc != -1) {
 309		/* Read in from the file byte by byte until a newline is reached */
 310		while ((result = read(filedesc, &buffer[bytes_read], 1)) == 1) {
 311			if (buffer[bytes_read] == '\n') {
 312				buffer[bytes_read] = '\0';
 313				bytes_read++;
 314				break;
 315			}
 316			bytes_read++;
 317		}
 318	}
 319
 320	/* Return the number of bytes read */
 321	if (result == -1)
 322		return result;
 323	else
 324		return bytes_read;
 325} /* readline */
 326/*============================================================================*/
 327
 328/*******************************************************************************
 329 *	translate_option()
 330 *******************************************************************************
 331 *
 332 *  DESCRIPTION:
 333 *
 334 *      This function takes a line read in from the config file and parses out
 335 *   the key/value pairs. It then determines which key has been parsed and sets
 336 *   the card's configuration based on the value given.
 337 *
 338 *  PARAMETERS:
 339 *
 340 *      buffer - a buffer containing a line to translate
 341 *      config - a pointer to the device's private adapter structure
 342 *
 343 *  RETURNS:
 344 *
 345 *      N/A
 346 *
 347 ******************************************************************************/
 348void translate_option(char *buffer, struct wl_private *lp)
 349{
 350	unsigned int value_convert = 0;
 351	int string_length = 0;
 352	char *key = NULL;
 353	char *value = NULL;
 354	u_char mac_value[ETH_ALEN];
 355	/*------------------------------------------------------------------------*/
 356
 357	DBG_FUNC("translate_option");
 358
 359	if (buffer == NULL || lp == NULL) {
 360		DBG_ERROR(DbgInfo, "Config file buffer and/or wavelan buffer ptr NULL\n");
 361		return;
 362	}
 363
 364	ParseConfigLine(buffer, &key, &value);
 365
 366	if (key == NULL || value == NULL)
 367		return;
 368
 369	/* Determine which key it is and perform the appropriate action */
 370
 371	/* Configuration parameters used in all scenarios */
 372#if DBG
 373	/* handle DebugFlag as early as possible so it starts its influence as early
 374	 * as possible
 375	 */
 376	if (strcmp(key, PARM_NAME_DEBUG_FLAG) == 0) {
 377		if (DebugFlag == ~0) {			/* if DebugFlag is not specified on the command line */
 378			if (DbgInfo->DebugFlag == 0) {	/* if pc_debug did not set DebugFlag (i.e.pc_debug is
 379											 * not specified or specified outside the 4-8 range
 380											 */
 381				DbgInfo->DebugFlag |= DBG_DEFAULTS;
 382			}
 383		} else {
 384			DbgInfo->DebugFlag = simple_strtoul(value, NULL, 0); /* ;?DebugFlag; */
 385		}
 386		DbgInfo->DebugFlag = simple_strtoul(value, NULL, 0); /* ;?Delete ASAP */
 387	}
 388#endif /* DBG */
 389	if (strcmp(key, PARM_NAME_AUTH_KEY_MGMT_SUITE) == 0) {
 390		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_AUTH_KEY_MGMT_SUITE, value);
 391
 392		value_convert = simple_strtoul(value, NULL, 0);
 393		if ((value_convert >= PARM_MIN_AUTH_KEY_MGMT_SUITE) || (value_convert <= PARM_MAX_AUTH_KEY_MGMT_SUITE))
 394			lp->AuthKeyMgmtSuite = value_convert;
 395		else
 396			DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_AUTH_KEY_MGMT_SUITE);
 397	} else if (strcmp(key, PARM_NAME_BRSC_2GHZ) == 0) {
 398		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_BRSC_2GHZ, value);
 399
 400		value_convert = simple_strtoul(value, NULL, 0);
 401		if ((value_convert >= PARM_MIN_BRSC) || (value_convert <= PARM_MAX_BRSC))
 402			lp->brsc[0] = value_convert;
 403		else
 404			DBG_WARNING(DbgInfo, "%s invaid; will be ignored\n", PARM_NAME_BRSC_2GHZ);
 405	} else if (strcmp(key, PARM_NAME_BRSC_5GHZ) == 0) {
 406		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_BRSC_5GHZ, value);
 407
 408		value_convert = simple_strtoul(value, NULL, 0);
 409		if ((value_convert >= PARM_MIN_BRSC) || (value_convert <= PARM_MAX_BRSC))
 410			lp->brsc[1] = value_convert;
 411		else
 412			DBG_WARNING(DbgInfo, "%s invaid; will be ignored\n", PARM_NAME_BRSC_5GHZ);
 413	} else if ((strcmp(key, PARM_NAME_DESIRED_SSID) == 0) || (strcmp(key, PARM_NAME_OWN_SSID) == 0)) {
 414		DBG_TRACE(DbgInfo, "SSID, value: %s\n", value);
 415
 416		memset(lp->NetworkName, 0, (PARM_MAX_NAME_LEN + 1));
 417
 418		/* Make sure the value isn't too long */
 419		string_length = strlen(value);
 420		if (string_length > PARM_MAX_NAME_LEN) {
 421			DBG_WARNING(DbgInfo, "SSID too long; will be truncated\n");
 422			string_length = PARM_MAX_NAME_LEN;
 423		}
 424
 425		memcpy(lp->NetworkName, value, string_length);
 426	}
 427#if 0
 428	else if (strcmp(key, PARM_NAME_DOWNLOAD_FIRMWARE) == 0) {
 429		DBG_TRACE(DbgInfo, "DOWNLOAD_FIRMWARE, value: %s\n", value);
 430		memset(lp->fw_image_filename, 0, (MAX_LINE_SIZE + 1));
 431		/* Make sure the value isn't too long */
 432		string_length = strlen(value);
 433		if (string_length > MAX_LINE_SIZE)
 434			DBG_WARNING(DbgInfo, "F/W image file name too long; will be ignored\n");
 435		else
 436			memcpy(lp->fw_image_filename, value, string_length);
 437	}
 438#endif
 439	else if (strcmp(key, PARM_NAME_ENABLE_ENCRYPTION) == 0) {
 440		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_ENABLE_ENCRYPTION, value);
 441
 442		value_convert = simple_strtoul(value, NULL, 0);
 443		if ((value_convert >= PARM_MIN_ENABLE_ENCRYPTION) && (value_convert <= PARM_MAX_ENABLE_ENCRYPTION))
 444			lp->EnableEncryption = value_convert;
 445		else
 446			DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_ENABLE_ENCRYPTION);
 447	} else if (strcmp(key, PARM_NAME_ENCRYPTION) == 0) {
 448		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_ENCRYPTION, value);
 449
 450		memset(lp->szEncryption, 0, sizeof(lp->szEncryption));
 451
 452		/* Make sure the value isn't too long */
 453		string_length = strlen(value);
 454		if (string_length > sizeof(lp->szEncryption)) {
 455			DBG_WARNING(DbgInfo, "%s too long; will be truncated\n", PARM_NAME_ENCRYPTION);
 456			string_length = sizeof(lp->szEncryption);
 457		}
 458
 459		memcpy(lp->szEncryption, value, string_length);
 460	} else if (strcmp(key, PARM_NAME_KEY1) == 0) {
 461		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_KEY1, value);
 462
 463		if (is_valid_key_string(value)) {
 464			memset(lp->DefaultKeys.key[0].key, 0, MAX_KEY_SIZE);
 465
 466			key_string2key(value, &lp->DefaultKeys.key[0]);
 467		} else {
 468			 DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_KEY1);
 469		}
 470	} else if (strcmp(key, PARM_NAME_KEY2) == 0) {
 471		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_KEY2, value);
 472
 473		if (is_valid_key_string(value)) {
 474			memset(lp->DefaultKeys.key[1].key, 0, MAX_KEY_SIZE);
 475
 476			key_string2key(value, &lp->DefaultKeys.key[1]);
 477		} else {
 478			 DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_KEY2);
 479		}
 480	} else if (strcmp(key, PARM_NAME_KEY3) == 0) {
 481		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_KEY3, value);
 482
 483		if (is_valid_key_string(value)) {
 484			memset(lp->DefaultKeys.key[2].key, 0, MAX_KEY_SIZE);
 485
 486			key_string2key(value, &lp->DefaultKeys.key[2]);
 487		} else {
 488			 DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_KEY3);
 489		}
 490	} else if (strcmp(key, PARM_NAME_KEY4) == 0) {
 491		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_KEY4, value);
 492
 493		if (is_valid_key_string(value)) {
 494			memset(lp->DefaultKeys.key[3].key, 0, MAX_KEY_SIZE);
 495
 496			key_string2key(value, &lp->DefaultKeys.key[3]);
 497		} else {
 498			 DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_KEY4);
 499		}
 500	}
 501	/* New Parameters for WARP */
 502	else if (strcmp(key, PARM_NAME_LOAD_BALANCING) == 0) {
 503		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_LOAD_BALANCING, value);
 504		lp->loadBalancing = parse_yes_no(value);
 505	} else if (strcmp(key, PARM_NAME_MEDIUM_DISTRIBUTION) == 0) {
 506		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_MEDIUM_DISTRIBUTION, value);
 507		lp->mediumDistribution = parse_yes_no(value);
 508	} else if (strcmp(key, PARM_NAME_MICROWAVE_ROBUSTNESS) == 0) {
 509		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_MICROWAVE_ROBUSTNESS, value);
 510		lp->MicrowaveRobustness = parse_yes_no(value);
 511	} else if (strcmp(key, PARM_NAME_MULTICAST_RATE) == 0) {
 512		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_MULTICAST_RATE, value);
 513
 514		value_convert = simple_strtoul(value, NULL, 0);
 515
 516		if ((value_convert >= PARM_MIN_MULTICAST_RATE) && (value_convert <= PARM_MAX_MULTICAST_RATE))
 517			lp->MulticastRate[0] = value_convert;
 518		else
 519			DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_MULTICAST_RATE);
 520	} else if (strcmp(key, PARM_NAME_OWN_CHANNEL) == 0) {
 521		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_OWN_CHANNEL, value);
 522
 523		value_convert = simple_strtoul(value, NULL, 0);
 524		if (wl_is_a_valid_chan(value_convert)) {
 525			if (value_convert > 14)
 526				value_convert = value_convert | 0x100;
 527			lp->Channel = value_convert;
 528		} else {
 529			DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_OWN_CHANNEL);
 530		}
 531	} else if (strcmp(key, PARM_NAME_OWN_NAME) == 0) {
 532		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_OWN_NAME, value);
 533
 534		memset(lp->StationName, 0, (PARM_MAX_NAME_LEN + 1));
 535
 536		/* Make sure the value isn't too long */
 537		string_length = strlen(value);
 538		if (string_length > PARM_MAX_NAME_LEN) {
 539			DBG_WARNING(DbgInfo, "%s too long; will be truncated\n", PARM_NAME_OWN_NAME);
 540			string_length = PARM_MAX_NAME_LEN;
 541		}
 542
 543		memcpy(lp->StationName, value, string_length);
 544	} else if (strcmp(key, PARM_NAME_RTS_THRESHOLD) == 0) {
 545		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD, value);
 546
 547		value_convert = simple_strtoul(value, NULL, 0);
 548		if ((value_convert >= PARM_MIN_RTS_THRESHOLD) && (value_convert <= PARM_MAX_RTS_THRESHOLD))
 549			lp->RTSThreshold = value_convert;
 550		else
 551			DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD);
 552	} else if (strcmp(key, PARM_NAME_SRSC_2GHZ) == 0) {
 553		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_SRSC_2GHZ, value);
 554
 555		value_convert = simple_strtoul(value, NULL, 0);
 556		if ((value_convert >= PARM_MIN_SRSC) || (value_convert <= PARM_MAX_SRSC))
 557			lp->srsc[0] = value_convert;
 558		else
 559			DBG_WARNING(DbgInfo, "%s invaid; will be ignored\n", PARM_NAME_SRSC_2GHZ);
 560	} else if (strcmp(key, PARM_NAME_SRSC_5GHZ) == 0) {
 561		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_SRSC_5GHZ, value);
 562
 563		value_convert = simple_strtoul(value, NULL, 0);
 564		if ((value_convert >= PARM_MIN_SRSC) || (value_convert <= PARM_MAX_SRSC))
 565			lp->srsc[1] = value_convert;
 566		else
 567			DBG_WARNING(DbgInfo, "%s invaid; will be ignored\n", PARM_NAME_SRSC_5GHZ);
 568	} else if (strcmp(key, PARM_NAME_SYSTEM_SCALE) == 0) {
 569		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_SYSTEM_SCALE, value);
 570
 571		value_convert = simple_strtoul(value, NULL, 0);
 572		if ((value_convert >= PARM_MIN_SYSTEM_SCALE) && (value_convert <= PARM_MAX_SYSTEM_SCALE))
 573			lp->DistanceBetweenAPs = value_convert;
 574		else
 575			DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_SYSTEM_SCALE);
 576	} else if (strcmp(key, PARM_NAME_TX_KEY) == 0) {
 577		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_TX_KEY, value);
 578
 579		value_convert = simple_strtoul(value, NULL, 0);
 580		if ((value_convert >= PARM_MIN_TX_KEY) && (value_convert <= PARM_MAX_TX_KEY))
 581			lp->TransmitKeyID = simple_strtoul(value, NULL, 0);
 582		else
 583			DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_KEY);
 584	} else if (strcmp(key, PARM_NAME_TX_RATE) == 0) {
 585		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE, value);
 586
 587		value_convert = simple_strtoul(value, NULL, 0);
 588		if ((value_convert >= PARM_MIN_TX_RATE) && (value_convert <= PARM_MAX_TX_RATE))
 589			lp->TxRateControl[0] = value_convert;
 590		else
 591			DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE);
 592	} else if (strcmp(key, PARM_NAME_TX_POW_LEVEL) == 0) {
 593		DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_TX_POW_LEVEL, value);
 594
 595		value_convert = simple_strtoul(value, NULL, 0);
 596		if ((value_convert >= PARM_MIN_TX_POW_LEVEL) || (value_convert <= PARM_MAX_TX_POW_LEVEL))
 597			lp->txPowLevel = value_convert;
 598		else
 599			DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_POW_LEVEL);
 600	}
 601
 602	/* Need to add? : Country code, Short/Long retry */
 603
 604	/* Configuration parameters specific to STA mode */
 605#if 1 /* ;? (HCF_TYPE) & HCF_TYPE_STA */
 606/* ;?seems reasonable that even an AP-only driver could afford this small additional footprint */
 607	if (CNV_INT_TO_LITTLE(lp->hcfCtx.IFB_FWIdentity.comp_id) == COMP_ID_FW_STA) {
 608					/* ;?should we return an error status in AP mode */
 609		if (strcmp(key, PARM_NAME_PORT_TYPE) == 0) {
 610			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_PORT_TYPE, value);
 611
 612			value_convert = simple_strtoul(value, NULL, 0);
 613			if ((value_convert == PARM_MIN_PORT_TYPE) || (value_convert == PARM_MAX_PORT_TYPE))
 614				lp->PortType = value_convert;
 615			else
 616				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_PORT_TYPE);
 617		} else if (strcmp(key, PARM_NAME_PM_ENABLED) == 0) {
 618			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_PM_ENABLED, value);
 619			value_convert = simple_strtoul(value, NULL, 0);
 620	/* ;? how about wl_main.c containing
 621	 * VALID_PARAM(PARM_PM_ENABLED <= WVLAN_PM_STATE_STANDARD ||
 622	 *					 (PARM_PM_ENABLED & 0x7FFF) <= WVLAN_PM_STATE_STANDARD);
 623	 */
 624			if ((value_convert & 0x7FFF) <= PARM_MAX_PM_ENABLED) {
 625				lp->PMEnabled = value_convert;
 626			} else {
 627				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_PM_ENABLED);
 628				/* ;?this is a data entry error, hence not a DBG_WARNING */
 629			}
 630		} else if (strcmp(key, PARM_NAME_CREATE_IBSS) == 0) {
 631			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_CREATE_IBSS, value);
 632			lp->CreateIBSS = parse_yes_no(value);
 633		} else if (strcmp(key, PARM_NAME_MULTICAST_RX) == 0) {
 634			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_MULTICAST_RX, value);
 635			lp->MulticastReceive = parse_yes_no(value);
 636		} else if (strcmp(key, PARM_NAME_MAX_SLEEP) == 0) {
 637			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_MAX_SLEEP, value);
 638
 639			value_convert = simple_strtoul(value, NULL, 0);
 640			if ((value_convert >= 0) && (value_convert <= 65535))
 641				lp->MaxSleepDuration = value_convert;
 642			else
 643				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_MAX_SLEEP);
 644		} else if (strcmp(key, PARM_NAME_NETWORK_ADDR) == 0) {
 645			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_NETWORK_ADDR, value);
 646
 647			if (parse_mac_address(value, mac_value) == ETH_ALEN)
 648				memcpy(lp->MACAddress, mac_value, ETH_ALEN);
 649			else
 650				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_NETWORK_ADDR);
 651		} else if (strcmp(key, PARM_NAME_AUTHENTICATION) == 0) {
 652			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_AUTHENTICATION, value);
 653
 654			value_convert = simple_strtoul(value, NULL, 0);
 655			if ((value_convert >= PARM_MIN_AUTHENTICATION) && (value_convert <= PARM_MAX_AUTHENTICATION))
 656				lp->authentication = value_convert;
 657			else
 658				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_AUTHENTICATION);
 659		} else if (strcmp(key, PARM_NAME_OWN_ATIM_WINDOW) == 0) {
 660			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_OWN_ATIM_WINDOW, value);
 661
 662			value_convert = simple_strtoul(value, NULL, 0);
 663			if ((value_convert >= PARM_MIN_OWN_ATIM_WINDOW) && (value_convert <= PARM_MAX_OWN_ATIM_WINDOW))
 664				lp->atimWindow = value_convert;
 665			else
 666				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_OWN_ATIM_WINDOW);
 667		} else if (strcmp(key, PARM_NAME_PM_HOLDOVER_DURATION) == 0) {
 668			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_PM_HOLDOVER_DURATION, value);
 669
 670			value_convert = simple_strtoul(value, NULL, 0);
 671			if ((value_convert >= PARM_MIN_PM_HOLDOVER_DURATION) && (value_convert <= PARM_MAX_PM_HOLDOVER_DURATION))
 672				lp->holdoverDuration = value_convert;
 673			else
 674				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_PM_HOLDOVER_DURATION);
 675		} else if (strcmp(key, PARM_NAME_PROMISCUOUS_MODE) == 0) {
 676			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_PROMISCUOUS_MODE, value);
 677			lp->promiscuousMode = parse_yes_no(value);
 678		} else if (strcmp(key, PARM_NAME_CONNECTION_CONTROL) == 0) {
 679			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_CONNECTION_CONTROL, value);
 680
 681			value_convert = simple_strtoul(value, NULL, 0);
 682			if ((value_convert >= PARM_MIN_CONNECTION_CONTROL) && (value_convert <= PARM_MAX_CONNECTION_CONTROL))
 683				lp->connectionControl = value_convert;
 684			else
 685				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_CONNECTION_CONTROL);
 686		}
 687
 688		/* Need to add? : Probe Data Rate */
 689	}
 690#endif  /* (HCF_TYPE) & HCF_TYPE_STA */
 691
 692	/* Configuration parameters specific to AP mode */
 693#if 1 /* ;? (HCF_TYPE) & HCF_TYPE_AP */
 694		/* ;?should we restore this to allow smaller memory footprint */
 695	if (CNV_INT_TO_LITTLE(lp->hcfCtx.IFB_FWIdentity.comp_id) == COMP_ID_FW_AP) {
 696		if (strcmp(key, PARM_NAME_OWN_DTIM_PERIOD) == 0) {
 697			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_OWN_DTIM_PERIOD, value);
 698
 699			value_convert = simple_strtoul(value, NULL, 0);
 700			if (value_convert >= PARM_MIN_OWN_DTIM_PERIOD)
 701				lp->DTIMPeriod = value_convert;
 702			else
 703				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_OWN_DTIM_PERIOD);
 704		} else if (strcmp(key, PARM_NAME_REJECT_ANY) == 0) {
 705			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_REJECT_ANY, value);
 706			lp->RejectAny = parse_yes_no(value);
 707		} else if (strcmp(key, PARM_NAME_EXCLUDE_UNENCRYPTED) == 0) {
 708			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_EXCLUDE_UNENCRYPTED, value);
 709			lp->ExcludeUnencrypted = parse_yes_no(value);
 710		} else if (strcmp(key, PARM_NAME_MULTICAST_PM_BUFFERING) == 0) {
 711			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_MULTICAST_PM_BUFFERING, value);
 712			lp->ExcludeUnencrypted = parse_yes_no(value);
 713		} else if (strcmp(key, PARM_NAME_INTRA_BSS_RELAY) == 0) {
 714			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_INTRA_BSS_RELAY, value);
 715			lp->ExcludeUnencrypted = parse_yes_no(value);
 716		} else if (strcmp(key, PARM_NAME_OWN_BEACON_INTERVAL) == 0) {
 717			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_OWN_BEACON_INTERVAL, value);
 718
 719			value_convert = simple_strtoul(value, NULL, 0);
 720			if (value_convert >= PARM_MIN_OWN_BEACON_INTERVAL)
 721				lp->ownBeaconInterval = value_convert;
 722			else
 723				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_OWN_BEACON_INTERVAL);
 724		} else if (strcmp(key, PARM_NAME_COEXISTENCE) == 0) {
 725			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_COEXISTENCE, value);
 726
 727			value_convert = simple_strtoul(value, NULL, 0);
 728			if (value_convert >= PARM_MIN_COEXISTENCE)
 729				lp->coexistence = value_convert;
 730			else
 731				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_COEXISTENCE);
 732		}
 733
 734#ifdef USE_WDS
 735		else if (strcmp(key, PARM_NAME_RTS_THRESHOLD1) == 0) {
 736			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD1, value);
 737
 738			value_convert = simple_strtoul(value, NULL, 0);
 739			if ((value_convert >= PARM_MIN_RTS_THRESHOLD) && (value_convert <= PARM_MAX_RTS_THRESHOLD))
 740				lp->wds_port[0].rtsThreshold = value_convert;
 741			else
 742				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD1);
 743		} else if (strcmp(key, PARM_NAME_RTS_THRESHOLD2) == 0) {
 744			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD2, value);
 745
 746			value_convert = simple_strtoul(value, NULL, 0);
 747			if ((value_convert >= PARM_MIN_RTS_THRESHOLD) && (value_convert <= PARM_MAX_RTS_THRESHOLD))
 748				lp->wds_port[1].rtsThreshold = value_convert;
 749			else
 750				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD2);
 751		} else if (strcmp(key, PARM_NAME_RTS_THRESHOLD3) == 0) {
 752			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD3, value);
 753
 754			value_convert = simple_strtoul(value, NULL, 0);
 755			if ((value_convert >= PARM_MIN_RTS_THRESHOLD) && (value_convert <= PARM_MAX_RTS_THRESHOLD))
 756				lp->wds_port[2].rtsThreshold = value_convert;
 757			else
 758				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD3);
 759		} else if (strcmp(key, PARM_NAME_RTS_THRESHOLD4) == 0) {
 760			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD4, value);
 761
 762			value_convert = simple_strtoul(value, NULL, 0);
 763			if ((value_convert >= PARM_MIN_RTS_THRESHOLD) && (value_convert <= PARM_MAX_RTS_THRESHOLD))
 764				lp->wds_port[3].rtsThreshold = value_convert;
 765			else
 766				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD4);
 767		} else if (strcmp(key, PARM_NAME_RTS_THRESHOLD5) == 0) {
 768			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD5, value);
 769
 770			value_convert = simple_strtoul(value, NULL, 0);
 771			if ((value_convert >= PARM_MIN_RTS_THRESHOLD) && (value_convert <= PARM_MAX_RTS_THRESHOLD))
 772				lp->wds_port[4].rtsThreshold = value_convert;
 773			else
 774				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD5);
 775		} else if (strcmp(key, PARM_NAME_RTS_THRESHOLD6) == 0) {
 776			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_RTS_THRESHOLD6, value);
 777
 778			value_convert = simple_strtoul(value, NULL, 0);
 779			if ((value_convert >= PARM_MIN_RTS_THRESHOLD) && (value_convert <= PARM_MAX_RTS_THRESHOLD))
 780				lp->wds_port[5].rtsThreshold = value_convert;
 781			else
 782				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_RTS_THRESHOLD6);
 783		} else if (strcmp(key, PARM_NAME_TX_RATE1) == 0) {
 784			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE1, value);
 785
 786			value_convert = simple_strtoul(value, NULL, 0);
 787			if ((value_convert >= PARM_MIN_TX_RATE) && (value_convert <= PARM_MAX_TX_RATE))
 788				lp->wds_port[0].txRateCntl = value_convert;
 789			else
 790				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE1);
 791		} else if (strcmp(key, PARM_NAME_TX_RATE2) == 0) {
 792			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE2, value);
 793
 794			value_convert = simple_strtoul(value, NULL, 0);
 795			if ((value_convert >= PARM_MIN_TX_RATE) && (value_convert <= PARM_MAX_TX_RATE))
 796				lp->wds_port[1].txRateCntl = value_convert;
 797			else
 798				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE2);
 799		} else if (strcmp(key, PARM_NAME_TX_RATE3) == 0) {
 800			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE3, value);
 801
 802			value_convert = simple_strtoul(value, NULL, 0);
 803			if ((value_convert >= PARM_MIN_TX_RATE) && (value_convert <= PARM_MAX_TX_RATE))
 804				lp->wds_port[2].txRateCntl = value_convert;
 805			else
 806				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE3);
 807		} else if (strcmp(key, PARM_NAME_TX_RATE4) == 0) {
 808			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE4, value);
 809
 810			value_convert = simple_strtoul(value, NULL, 0);
 811			if ((value_convert >= PARM_MIN_TX_RATE) && (value_convert <= PARM_MAX_TX_RATE))
 812				lp->wds_port[3].txRateCntl = value_convert;
 813			else
 814				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE4);
 815		} else if (strcmp(key, PARM_NAME_TX_RATE5) == 0) {
 816			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE5, value);
 817
 818			value_convert = simple_strtoul(value, NULL, 0);
 819			if ((value_convert >= PARM_MIN_TX_RATE) && (value_convert <= PARM_MAX_TX_RATE))
 820				lp->wds_port[4].txRateCntl = value_convert;
 821			else
 822				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE5);
 823		} else if (strcmp(key, PARM_NAME_TX_RATE6) == 0) {
 824			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_TX_RATE6, value);
 825
 826			value_convert = simple_strtoul(value, NULL, 0);
 827			if ((value_convert >= PARM_MIN_TX_RATE) && (value_convert <= PARM_MAX_TX_RATE))
 828				lp->wds_port[5].txRateCntl = value_convert;
 829			else
 830				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_TX_RATE6);
 831		} else if (strcmp(key, PARM_NAME_WDS_ADDRESS1) == 0) {
 832			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS1, value);
 833
 834			if (parse_mac_address(value, mac_value) == ETH_ALEN)
 835				memcpy(lp->wds_port[0].wdsAddress, mac_value, ETH_ALEN);
 836			else
 837				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS1);
 838		} else if (strcmp(key, PARM_NAME_WDS_ADDRESS2) == 0) {
 839			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS2, value);
 840
 841			if (parse_mac_address(value, mac_value) == ETH_ALEN)
 842				memcpy(lp->wds_port[1].wdsAddress, mac_value, ETH_ALEN);
 843			else
 844				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS2);
 845		} else if (strcmp(key, PARM_NAME_WDS_ADDRESS3) == 0) {
 846			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS3, value);
 847
 848			if (parse_mac_address(value, mac_value) == ETH_ALEN)
 849				memcpy(lp->wds_port[2].wdsAddress, mac_value, ETH_ALEN);
 850			else
 851				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS3);
 852		} else if (strcmp(key, PARM_NAME_WDS_ADDRESS4) == 0) {
 853			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS4, value);
 854
 855			if (parse_mac_address(value, mac_value) == ETH_ALEN)
 856				memcpy(lp->wds_port[3].wdsAddress, mac_value, ETH_ALEN);
 857			else
 858				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS4);
 859		} else if (strcmp(key, PARM_NAME_WDS_ADDRESS5) == 0) {
 860			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS5, value);
 861
 862			if (parse_mac_address(value, mac_value) == ETH_ALEN)
 863				memcpy(lp->wds_port[4].wdsAddress, mac_value, ETH_ALEN);
 864			else
 865				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS5);
 866		} else if (strcmp(key, PARM_NAME_WDS_ADDRESS6) == 0) {
 867			DBG_TRACE(DbgInfo, "%s, value: %s\n", PARM_NAME_WDS_ADDRESS6, value);
 868
 869			if (parse_mac_address(value, mac_value) == ETH_ALEN)
 870				memcpy(lp->wds_port[5].wdsAddress, mac_value, ETH_ALEN);
 871			else
 872				DBG_WARNING(DbgInfo, "%s invalid; will be ignored\n", PARM_NAME_WDS_ADDRESS6);
 873		}
 874#endif  /* USE_WDS */
 875	}
 876#endif  /* (HCF_TYPE) & HCF_TYPE_AP */
 877
 878	return;
 879} /* translate_option */
 880/*============================================================================*/
 881
 882/*******************************************************************************
 883 *	parse_mac_address()
 884 *******************************************************************************
 885 *
 886 *  DESCRIPTION:
 887 *
 888 *      This function will parse a mac address string and convert it to a byte
 889 *   array.
 890 *
 891 *  PARAMETERS:
 892 *
 893 *      value       - the MAC address, represented as a string
 894 *      byte_array  - the MAC address, represented as a byte array of length
 895 *                    ETH_ALEN
 896 *
 897 *  RETURNS:
 898 *
 899 *      The number of bytes in the final MAC address, should equal to ETH_ALEN.
 900 *
 901 ******************************************************************************/
 902int parse_mac_address(char *value, u_char *byte_array)
 903{
 904	int     value_offset = 0;
 905	int     array_offset = 0;
 906	int     field_offset = 0;
 907	char    byte_field[3];
 908	/*------------------------------------------------------------------------*/
 909
 910	memset(byte_field, '\0', 3);
 911
 912	while (value[value_offset] != '\0') {
 913		/* Skip over the colon chars seperating the bytes, if they exist */
 914		if (value[value_offset] == ':') {
 915			value_offset++;
 916			continue;
 917		}
 918
 919		byte_field[field_offset] = value[value_offset];
 920		field_offset++;
 921		value_offset++;
 922
 923		/* Once the byte_field is filled, convert it and store it */
 924		if (field_offset == 2) {
 925			byte_field[field_offset] = '\0';
 926			byte_array[array_offset] = simple_strtoul(byte_field, NULL, 16);
 927			field_offset = 0;
 928			array_offset++;
 929		}
 930	}
 931
 932	/* Use the array_offset as a check; 6 bytes should be written to the
 933	   byte_array */
 934	return array_offset;
 935} /* parse_mac_address */
 936/*============================================================================*/
 937
 938/*******************************************************************************
 939 *	ParseConfigLine()
 940 *******************************************************************************
 941 *
 942 *  DESCRIPTION:
 943 *
 944 *      Parses a line from the configuration file into an L-val and an R-val,
 945 *  representing a key/value pair.
 946 *
 947 *  PARAMETERS:
 948 *
 949 *      pszLine     - the line from the config file to parse
 950 *      ppszLVal    - the resulting L-val (Key)
 951 *      ppszRVal    - the resulting R-val (Value)
 952 *
 953 *  RETURNS:
 954 *
 955 *      N/A
 956 *
 957 ******************************************************************************/
 958void ParseConfigLine(char *pszLine, char **ppszLVal, char **ppszRVal)
 959{
 960	int i;
 961	int size;
 962	/*------------------------------------------------------------------------*/
 963
 964	DBG_FUNC("ParseConfigLine");
 965	DBG_ENTER(DbgInfo);
 966
 967	/* get a snapshot of our string size */
 968	size      = strlen(pszLine);
 969	*ppszLVal = NULL;
 970	*ppszRVal = NULL;
 971
 972	if (pszLine[0] != '#' &&							/* skip the line if it is a comment */
 973		 pszLine[0] != '\n' &&							/* if it's an empty UNIX line, do nothing */
 974		 !(pszLine[0] == '\r' && pszLine[1] == '\n')	/* if it's an empty MS-DOS line, do nothing */
 975	   ) {
 976		/* advance past any whitespace, and assign the L-value */
 977		for (i = 0; i < size; i++) {
 978			if (pszLine[i] != ' ') {
 979				*ppszLVal = &pszLine[i];
 980				break;
 981			}
 982		}
 983		/* advance to the end of the l-value*/
 984		for (i++; i < size; i++) {
 985			if (pszLine[i] == ' ' || pszLine[i] == '=') {
 986				pszLine[i] = '\0';
 987				break;
 988			}
 989		}
 990		/* make any whitespace and the equal sign a NULL character, and
 991		   advance to the R-Value */
 992		for (i++; i < size; i++) {
 993			if (pszLine[i] == ' ' || pszLine[i] == '=') {
 994				pszLine[i] = '\0';
 995				continue;
 996			}
 997			*ppszRVal = &pszLine[i];
 998			break;
 999		}
1000		/* make the line ending character(s) a NULL */
1001		for (i++; i < size; i++) {
1002			if (pszLine[i] == '\n')
1003				pszLine[i] = '\0';
1004			if ((pszLine[i] == '\r') && (pszLine[i+1] == '\n'))
1005				pszLine[i] = '\0';
1006		}
1007	}
1008	DBG_LEAVE(DbgInfo);
1009} /* ParseConfigLine */
1010/*============================================================================*/
1011
1012#endif  /* USE_PROFILE */