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