/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

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