/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <errno.h>
#include <ctype.h>
#include <stdarg.h>
#include <fcntl.h>
#include <unistd.h>
#include <net/if.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/ddi.h>
#include <stropts.h>
#include <assert.h>
#include <termios.h>
#include <time.h>
#include <string.h>
#include <strings.h>
#include <auth_attr.h>
#include <auth_list.h>
#include <libdevinfo.h>
#include <secdb.h>
#include <priv.h>
#include <pwd.h>
#include <umem.h>
#include <locale.h>
#include <libintl.h>
#include <dirent.h>
#include <inet/wifi_ioctl.h>

/*
 * Debug information
 */
#ifdef	DEBUG
int wifi_debug = 0;
void wifi_dbgprintf(char *fmt, ...);
#define	PRTDBG(msg) if (wifi_debug > 1) wifi_dbgprintf msg
#else /* DEBUG */
#define	PRTDBG(msg)
#endif /* DEBUG */

#define	MAX_HISTORY_NUM			10
#define	MAX_PREFERENCE_NUM		10
#define	MAX_SCANBUF_LEN			256
#define	MAX_CONFIG_FILE_LENGTH		256
#define	MAX_LOADPF_LENGTH		256
#define	LOADPROFILE_TIMEOUT		10
#define	RECORD_ADD		0
#define	RECORD_DEL		1
/*
 * Wificonfig exit status
 */
#define	WIFI_EXIT_DEF		0
#define	WIFI_FATAL_ERR		1
#define	WIFI_IMPROPER_USE	2
#define	WIFI_MINOR_ERR		3

#define	WIFI_LOCKF "/var/run/lockf_wifi"

typedef enum {
	PREFERENCE,
	HISTORY,
	ACTIVEP,
	PROFILE,
	OTHER
} list_type_t;

#define	WIFI_PREFER	"{preference}"
#define	WIFI_HISTORY	"{history}"
#define	WIFI_ACTIVEP	"{active_profile}"

typedef enum {
	LINKSTATUS = 0,
	BSSID,
	ESSID,
	BSSTYPE,
	CREATEIBSS,
	CHANNEL,
	RATES,
	POWERMODE,
	AUTHMODE,
	ENCRYPTION,
	WEPKEYID,
	WEPKEY,
	SIGNAL,
	RADIOON,
	WLANLIST,
	CONFIG_ITEM_END /* 15 */
} config_item_t;
typedef struct ae {
	struct ae *ae_next;
	char *ae_arg;
}ae_t;
typedef struct aelist {
	int ael_argc;
	ae_t *ael_head, *ael_tail;
	list_type_t type;
}aelist_t;
typedef struct section {
	struct section *section_next;
	aelist_t *list;
	char *section_id;
}section_t;

/*
 * config_file_t is an abstract of configration file,
 * either/etc/inet/wifi/wifi.<interface> or /etc/inet/secret/
 * wifi/wifiwepkey.<interface>
 */
typedef struct config_file {
	int section_argc;
	section_t *section_head, *section_tail;
}config_file_t;

static config_file_t *gp_config_file = NULL;
static config_file_t *gp_wepkey_file = NULL;
static char *p_file_wifi = "/etc/inet/wifi";
static char *p_file_wifiwepkey = "/etc/inet/secret/wifiwepkey";

typedef enum {
	AUTH_WEP = 0,
	AUTH_OTHER = 1
} wifi_auth_t;

static char *p_auth_string[] = {
	WIFI_WEP_AUTH,
	WIFI_CONFIG_AUTH
};

/*
 * gbuf: is a global buf, which is used to communicate between the user and
 * the driver
 */
static wldp_t *gbuf = NULL;
static char *gExecName = NULL;

static void print_error(uint32_t);
static void *safe_malloc(size_t);
static void *safe_calloc(size_t, size_t);
static char *safe_strdup(const char *s1);
static void safe_snprintf(char *s, size_t n,
    const char *format, ...);
static void safe_fclose(FILE *stream);
static void new_ae(aelist_t *ael, const char *arg);
static aelist_t *new_ael(list_type_t type);
static config_file_t *new_config_file();
static void new_section(config_file_t *p_config_file, aelist_t *p_list,
	const char *section_id);
static void destroy_config(config_file_t *p_config_file);
static config_file_t *parse_file(const char *pfile);
static char **aeltoargv(aelist_t *ael, int *ael_num);
static boolean_t fprint_config_file(config_file_t *p_config_file,
	const char *file_name);
static char *append_pa(const char *arg);
static section_t *find_section(config_file_t *p_config_file,
	const char *section_id);
static ae_t *find_ae(aelist_t *plist, const char *arg);
static void update_aelist(aelist_t *plist, const char *arg);
static const char *get_value(const char *arg);
static char *find_active_profile(int);
static const char *essid_of_profile(const char *profile);
static boolean_t search_interface(char *interface);
static int open_dev(char *devname);
static boolean_t call_ioctl(int, int, uint32_t, uint32_t);
static boolean_t del_prefer(config_file_t *p_config_file, const char *prefer,
    boolean_t rflag);
static boolean_t del_section(config_file_t *p_config_file, char *section_id);
static boolean_t set_prefer(config_file_t *p_config_file, const char *prefer,
	int rank);
static void add_to_history(config_file_t *p_config_file,
    int argc, char **argv);
static boolean_t check_authority(wifi_auth_t type);
static void heuristic_load(int fd, uint32_t ess_num, wl_ess_conf_t **);
static char *select_profile(int fd, int readonly, int timeout);
static char *construct_format(uint32_t nt);
static void print_gbuf(config_item_t index);
static boolean_t items_in_profile(aelist_t *, aelist_t *, int, char **);
static char *get_commit_key(int, int, char **);
static void print_wepkey_info(const char *id, const char *wepkeyn);
static void  do_print_usage();
static boolean_t do_print_support_params(int fd);
static boolean_t do_autoconf(int fd, int argc, char **argv);
static boolean_t do_startconf(int fd, int argc, char **argv);
static boolean_t do_loadpf(int fd, int argc, char **argv);
static boolean_t do_disconnect(int fd, int argc, char **argv);
static boolean_t do_printpf(int fd, int argc, char **argv);
static boolean_t do_restoredef(int fd, int argc, char **argv);
static boolean_t do_history(int fd, int argc, char **argv);
static boolean_t do_deletepf(int fd, int argc, char **argv);
static boolean_t do_wepkey(int fd, int argc, char **argv);
static boolean_t do_setprefer(int fd, int argc, char **arg);
static boolean_t do_rmprefer(int fd, int argc, char **argv);
static boolean_t do_lsprefer(int fd, int argc, char **argv);
static boolean_t do_wlanlist(int fd, int argc, char **argv);
static boolean_t do_showstatus(int fd, int argc, char **argv);
static boolean_t do_getprofparam(int fd, int argc, char **argv);
static boolean_t do_setprofparam(int fd, int argc, char **argv);
static boolean_t do_setprofwepkey(int fd, int argc, char **argv);
static boolean_t is_rates_support(int fd, int num, uint8_t *rates);
static boolean_t do_set_bsstype(int fd, const char *arg);
static boolean_t do_set_essid(int fd, const char *arg);
static boolean_t do_set_powermode(int fd, const char *arg);
static boolean_t do_set_rates(int fd, const char *arg);
static boolean_t do_set_channel(int fd, const char *arg);
static boolean_t do_set_createibss(int fd, const char *arg);
static boolean_t do_set_radioon(int fd, const char *arg);
static boolean_t do_set_wepkeyid(int fd, const char *arg);
static boolean_t do_set_encryption(int fd, const char *arg);
static boolean_t do_set_authmode(int fd, const char *arg);
static boolean_t do_set_wepkey(int fd, const char *pbuf);
static boolean_t do_get_createibss(int fd);
static boolean_t do_get_bsstype(int fd);
static boolean_t do_get_essid(int fd);
static boolean_t do_get_bssid(int fd);
static boolean_t do_get_radioon(int fd);
static boolean_t do_get_signal(int fd);
static boolean_t do_get_wepkeyid(int fd);
static boolean_t do_get_encryption(int fd);
static boolean_t do_get_authmode(int fd);
static boolean_t do_get_powermode(int fd);
static boolean_t do_get_rates(int fd);
static boolean_t do_get_wlanlist(int fd);
static boolean_t do_get_linkstatus(int fd);
static boolean_t do_get_channel(int fd);
static boolean_t do_get(int fd, int argc, char **argv);
static boolean_t do_set(int fd, int argc, char **argv);
static boolean_t do_createprofile(int fd, int argc, char **argv);
static boolean_t value_is_valid(config_item_t item, const char *value);

typedef struct cmd_ops {
	char cmd[32];
	boolean_t (*p_do_func)(int fd, int argc, char **argv);
	boolean_t b_auth;
	boolean_t b_fileonly; /* operation only on the config file */
	boolean_t b_readonly; /* only read from the card or config file */
} cmd_ops_t;
static cmd_ops_t do_func[] = {
	{
		"autoconf",
		do_autoconf,
		B_TRUE,
		B_FALSE,
		B_FALSE
	},
	{
		"startconf",
		do_startconf,
		B_TRUE,
		B_FALSE,
		B_TRUE
	},
	{
		"connect",
		do_loadpf,
		B_TRUE,
		B_FALSE,
		B_FALSE
	},
	{
		"disconnect",
		do_disconnect,
		B_TRUE,
		B_FALSE,
		B_FALSE
	},
	{
		"showprofile",
		do_printpf,
		B_FALSE,
		B_TRUE,
		B_TRUE
	},
	{
		"deleteprofile",
		do_deletepf,
		B_TRUE,
		B_TRUE,
		B_FALSE
	},
	{
		"history",
		do_history,
		B_FALSE,
		B_TRUE,
		B_TRUE
	},
	{
		"listprefer",
		do_lsprefer,
		B_FALSE,
		B_TRUE,
		B_TRUE
	},
	{
		"removeprefer",
		do_rmprefer,
		B_TRUE,
		B_TRUE,
		B_FALSE
	},
	{
		"setprefer",
		do_setprefer,
		B_TRUE,
		B_TRUE,
		B_FALSE
	},
	{
		"setwepkey",
		do_wepkey,
		B_TRUE,
		B_FALSE,
		B_FALSE
	},
	{
		"restoredef",
		do_restoredef,
		B_TRUE,
		B_FALSE,
		B_FALSE
	},
	{
		"getparam",
		do_get,
		B_FALSE,
		B_FALSE,
		B_TRUE
	},
	{
		"setparam",
		do_set,
		B_TRUE,
		B_FALSE,
		B_FALSE
	},
	{
		"createprofile",
		do_createprofile,
		B_TRUE,
		B_TRUE,
		B_FALSE
	},
	{
		"scan",
		do_wlanlist,
		B_FALSE,
		B_FALSE,
		B_FALSE
	},
	{
		"showstatus",
		do_showstatus,
		B_FALSE,
		B_FALSE,
		B_TRUE
	},
	{
		"setprofileparam",
		do_setprofparam,
		B_TRUE,
		B_TRUE,
		B_FALSE
	},
	{
		"getprofileparam",
		do_getprofparam,
		B_FALSE,
		B_TRUE,
		B_TRUE
	},
	{
		"setprofilewepkey",
		do_setprofwepkey,
		B_TRUE,
		B_TRUE,
		B_FALSE
	}
};


typedef enum {RW, RO, WO} rw_property_t;
typedef struct gs_ops {
	config_item_t index;
	char cmd[32];
	boolean_t (*p_do_get_func)(int fd);
	boolean_t (*p_do_set_func)(int fd, const char *arg);
	rw_property_t rw;
} gs_ops_t;
static gs_ops_t do_gs_func[] = {
	{LINKSTATUS, "linkstatus", NULL, NULL, RO},
	{BSSID, "bssid", do_get_bssid, NULL, RO},
	{ESSID, "essid", do_get_essid, do_set_essid, RW},
	{BSSTYPE, "bsstype", do_get_bsstype, do_set_bsstype, RW},
	{CREATEIBSS, "createibss", do_get_createibss, do_set_createibss, RW},
	{CHANNEL, "channel", do_get_channel, do_set_channel, RW},
	{RATES, "rates", do_get_rates, do_set_rates, RW},
	{POWERMODE, "powermode", do_get_powermode, do_set_powermode, RW},
	{AUTHMODE, "authmode", do_get_authmode, do_set_authmode, RW},
	{ENCRYPTION, "encryption", do_get_encryption, do_set_encryption, RW},
	{WEPKEYID, "wepkeyindex", do_get_wepkeyid, do_set_wepkeyid, RW},
	{WEPKEY, "wepkey|1-4", NULL, do_set_wepkey, WO},
	{SIGNAL, "signal", do_get_signal, NULL, RO},
	{RADIOON, "radio",	do_get_radioon, do_set_radioon, RW},
};

#define	N_FUNC		sizeof (do_func) / sizeof (cmd_ops_t)
#define	N_GS_FUNC 	sizeof (do_gs_func) / sizeof (gs_ops_t)

/*
 * valid rate value
 */
typedef	struct wifi_rates_tab {
	char *rates_s;
	uint8_t rates_i;
	uint8_t rates_reserve0;
	uint8_t rates_reserve1;
	uint8_t rates_reserve2;
} wifi_rates_tab_t;

/*
 * the rates value is in increments of 500kb/s.
 * according to the 802.11 a/b/g specs(IEEE):
 * 802.11b(IEEE Std 802.11b-1999) page35, rates should be:
 *	X02, X04, X0b, X16
 * 802.11a(IEEE Std 802.11a-1999) page47, rates should be:
 *	6,9,12,18,24,36,48,54 Mb/s
 * 802.11g(IEEE Std 802.11g-2003) page44, rates should be:
 *	1,2,5.5,11,6,9,12,18,22,24,33,36,48,54 Mb/s
 */
#define	WIFI_RATES_NUM	14
static wifi_rates_tab_t wifi_rates_s[WIFI_RATES_NUM] = {
	{"1",	WL_RATE_1M,	0,	0,	0},
	{"2",	WL_RATE_2M,	0,	0,	0},
	{"5.5",	WL_RATE_5_5M,	0,	0,	0},
	{"6",	WL_RATE_6M,	0,	0,	0},
	{"9",	WL_RATE_9M,	0,	0,	0},
	{"11",	WL_RATE_11M,	0,	0,	0},
	{"12",	WL_RATE_12M,	0,	0,	0},
	{"18",	WL_RATE_18M,	0,	0,	0},
	{"22",	WL_RATE_22M,	0,	0,	0},
	{"24",	WL_RATE_24M,	0,	0,	0},
	{"33",	WL_RATE_33M,	0,	0,	0},
	{"36",	WL_RATE_36M,	0,	0,	0},
	{"48",	WL_RATE_48M,	0,	0,	0},
	{"54",	WL_RATE_54M,	0,	0,	0}
};
/* print the error message on why set or get ioctl command failed. */
static void
print_error(uint32_t errorno)
{
	char *buf;

	switch (errorno) {
	case WL_SUCCESS:
		buf = gettext("command succeeded");
		break;
	case WL_NOTSUPPORTED:
	case WL_LACK_FEATURE:
	case WL_HW_ERROR:
	case WL_ACCESS_DENIED:
		buf = strerror(errorno);
		break;
	case WL_READONLY:
		buf = gettext("parameter read-only");
		break;
	case WL_WRITEONLY:
		buf = gettext("parameter write-only");
		break;
	case WL_NOAP:
		buf = gettext("no access point available");
		break;
	default:
		buf = gettext("unknown error");
		break;
	}
	(void) fprintf(stderr, "%s\n", buf);
}

static void *
safe_malloc(size_t size)
{
	void *buf;

	buf = malloc(size);
	if (buf == NULL) {
		(void) fprintf(stderr, gettext("%s: malloc: %s\n"),
		    gExecName, strerror(errno));
		exit(WIFI_FATAL_ERR);
	}
	return (buf);
}

static void *
safe_calloc(size_t nelem, size_t elsize)
{
	void *buf;

	buf = calloc(nelem, elsize);
	if (buf == NULL) {
		(void) fprintf(stderr, gettext("%s: calloc: %s\n"),
		    gExecName, strerror(errno));
		exit(WIFI_FATAL_ERR);
	}
	return (buf);
}

static char *
safe_strdup(const char *s1)
{
	char *p;

	p = strdup(s1);
	if (p == NULL) {
		(void) fprintf(stderr, gettext("%s: strdup: %s\n"),
		    gExecName, strerror(errno));
		exit(WIFI_FATAL_ERR);
	}
	return (p);
}

static void
safe_snprintf(char *s, size_t n,  const  char  *format, ...)
{
	int len;
	va_list ap;
	va_start(ap, format);

	len = vsnprintf(s, n, format, ap);
	if ((len <= 0) || (len > n - 1)) {
		(void) fprintf(stderr,
		    gettext("%s: snprintf: %s\n"),
		    gExecName, strerror(errno));
		exit(WIFI_FATAL_ERR);
	}
	va_end(ap);
}

static void
safe_fclose(FILE *stream)
{
	int err;

	err = fclose(stream);
	if (err == EOF) {
		(void) fprintf(stderr, gettext("%s: fclose: %s\n"),
		    gExecName, strerror(errno));
		exit(WIFI_FATAL_ERR);
	}
}
/*
 * new_ae: Add an element with content pointed by arg to the list *ael.
 */
static void
new_ae(aelist_t *ael, const char *arg)
{
	ae_t *pae = NULL;

	PRTDBG(("new_ae(0x%x, \"%s\")\n", ael, arg));
	assert((ael != NULL) && (arg != NULL));

	pae = safe_calloc(sizeof (*pae), 1);
	pae->ae_arg = safe_strdup(arg);
	pae->ae_next = NULL;

	if (ael->ael_tail == NULL) {
		ael->ael_head = pae;
	} else {
		ael->ael_tail->ae_next = pae;
	}
	ael->ael_tail = pae;
	ael->ael_argc++;
}
/*
 * new_ael:  Create a new aelist with list_type "type"
 * and return the list pointer.
 */
static aelist_t *
new_ael(list_type_t type)
{
	aelist_t *plist;

	plist = safe_calloc(sizeof (*plist), 1);
	plist->type = type;
	plist->ael_argc = 0;
	plist->ael_head = plist->ael_tail = NULL;

	PRTDBG(("new_ael(%d) = 0x%x\n", type, plist));
	return (plist);
}

/*
 * new_config_file: Creates a new config_file_t struct which is counterpart of
 * of the configration file, and return the pointer.
 */
static config_file_t *
new_config_file()
{
	config_file_t *p_config_file;

	p_config_file = safe_calloc(sizeof (config_file_t), 1);
	p_config_file->section_argc = 0;
	p_config_file->section_head = p_config_file->section_tail = NULL;

	PRTDBG(("new_config_file() = 0x%x\n", p_config_file));
	return (p_config_file);
}

/*
 * new_section: Add a list pointed by "p_list", with identity "section_id" to
 * the config_file_t struct pointed by "p_config_file"
 */
static void
new_section(config_file_t *p_config_file, aelist_t *p_list,
    const char *section_id)
{
	section_t *p_section = NULL;

	PRTDBG(("new_section(0x%x, 0x%x, \"%s\")\n", p_config_file, p_list,
	    section_id));
	assert((p_config_file != NULL) && (p_list != NULL) &&
	    (section_id != NULL));

	p_section = safe_calloc(sizeof (*p_section), 1);
	p_section->list = p_list;
	p_section->section_next = NULL;
	p_section->section_id = safe_strdup(section_id);

	if (p_config_file->section_tail == NULL) {
		p_config_file->section_head = p_section;
	} else {
		p_config_file->section_tail->section_next = p_section;
	}
	p_config_file->section_tail = p_section;
	p_config_file->section_argc++;
}

/*
 * destroy_config:Destroy the config_file struct
 */
static void
destroy_config(config_file_t *p_config_file)
{
	section_t *p_section = NULL;
	aelist_t *p_list = NULL;
	ae_t *pae = NULL;

	PRTDBG(("destory_config(0x%x)\n", p_config_file));
	assert(p_config_file != NULL);

	p_section = p_config_file->section_head;
	while (p_section != NULL) {
		p_list = p_section->list;
		if (p_list != NULL) {
			pae = p_list->ael_head;
			while (pae != NULL) {
				if (pae->ae_arg != NULL)
					free(pae->ae_arg);
				pae->ae_arg = NULL;
				pae = pae->ae_next;
				free(p_list->ael_head);
				p_list->ael_head = pae;
			}
			free(p_list);
			p_list = NULL;
		}
		if (p_section->section_id != NULL)
			free(p_section->section_id);
		p_section->section_id = NULL;
		p_section = p_section->section_next;
		free(p_config_file->section_head);
		p_config_file->section_head = p_section;
	}
	free(p_config_file);
	p_config_file = NULL;
}

/*
 * parse_file: Parse each section of the configration file
 * and construct the config_file_t structure.
 * Example:
 * A config file has contents below:
 *
 * {preferrence}
 * essid=ap7-3
 * essid=linksys
 *
 * {history}
 * essid=ap7-3
 * essid=ap7-2
 *
 * [ap7-3]
 * essid=ap7-3
 * wepkeyid=3
 * channel=11
 * rates=1,2
 *
 * [linksys]
 * essid=linksys
 * createibss=BSS
 * authmode=OPENSYSTEM
 * wepkeyid=1
 *
 * then its config_file_t structure will be:
 *
 *                        config_file_t
 *                       |~~~~~~~~~~~~~~~~~~~~~~~~~~|
 *                       |      section_argc=5      |
 *                       |~~~~~~~~~~~~T~~~~~~~~~~~~~|
 *                      /|   *head    |    *tail    |\
 *                     / ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \
 *                    /                                \
 *                   /	                                \
 *                  /                                    \
 *                 /                                      \
 *                /                                        \
 *  section_t    V           section_t                      V section_t
 * |~~~~~~~~~~~~~~~|~~|     |~~~~~~~~~~~~~~~|~~|      |~~~~~~~~~~~~~~|~~|
 * |"{preferrence}"|  |     |  "{history}"  |  |      | "[linksys]"  |  |
 * |~~~~~~~~~~~~~~~| -+---->|~~~~~~~~~~~~~~~| -+->..->|~~~~~~~~~~~~~~| -+->NULL
 * |    *list      |  |     |    *list      |  |      |    *list     |  |
 * ~~T~~~~~~~~~~~~~~~~~     ~~~T~~~~~~~~~~~~~~~~      ~~~T~~~~~~~~~~~~~~~
 *   |                         |                         |
 *   |                         |                         |
 *   V aelist_t                V aelist_t                V aelist_t
 * |~~~~~~~~~~~~~|          |~~~~~~~~~~~~~|           |~~~~~~~~~~~~~|
 * |  argc=2     |          |  argc=3     |           |  argc=4     |
 * |~~~~~~~~~~~~~|          |~~~~~~~~~~~~~|           |~~~~~~~~~~~~~|
 * |PREFFERRENCE |          |   HISTORY   |           |   PROFILE   |
 * |~~~~~~T~~~~~~|          |~~~~~~T~~~~~~|           |~~~~~~T~~~~~~|
 * |*head |*tail |\         |*head |*tail |\          |*head |*tail |
 * ~~T~~~~~~~~~~~~ \        ~~T~~~~~~~~~~~~ \        /~~~~~~~~~~~~~~~\
 *   |              \         V              V      /                 \
 *   |               \        ...            ...   /                   \
 *   V ae_t           V  ae_t             ae_t    V           ae_t      V
 * |~~~~~~~~~T~~|  |~~~~~~~~~T~~|       |~~~~~~~~~T~~|      |~~~~~~~~~T~~|
 * |"essid=  | -+->|"essid=  | -+->NULL |"essid=  | -+->..->|"wepkeyid| -+->NULL
 * | ap7-3"  |  |  | linksys"|  |       | linksys"|  |      | =1"     |  |
 * ~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~       ~~~~~~~~~~~~~~      ~~~~~~~~~~~~~~
 *
 */

static config_file_t *
parse_file(const char *pfile)
{
	FILE *file = NULL;
	int fd = 0;
	char buf_line[256];
	config_file_t *p_config_file;
	list_type_t cur_list = OTHER;
	aelist_t *prefer_list = NULL;
	aelist_t *history_list = NULL;
	aelist_t *profile_list = NULL;
	aelist_t *activep_list = NULL;

	assert(pfile != NULL);
	/*
	 * The files /etc/inet/wifi and /etc/inet/secret/wifiwepkey should
	 * be opened with "r" attribute. If these two files do not exist,
	 * create them here.
	 */
	file = fopen(pfile, "r");

	if (file == NULL) {
		fd = open(pfile, O_CREAT|O_EXCL|O_RDWR, 0600);
		if (fd < 0) {
			(void) fprintf(stderr, gettext("%s: failed to open %s"
			    "\n"), gExecName, pfile);
			goto error1;
		}
		file = fdopen(fd, "w");
		(void) chmod(pfile, S_IRUSR);
	}

	p_config_file = new_config_file();

	while (fgets(buf_line, sizeof (buf_line), file) != NULL) {
		if ((buf_line[0] == '\n') || (buf_line[0] == ' '))
			continue;
		/* replace the old '\n' to '\0' */
		buf_line[strlen(buf_line) - 1] = '\0';
		if (strstr(buf_line, WIFI_PREFER) == buf_line) {
			if (prefer_list == NULL) {
				cur_list = PREFERENCE;
				prefer_list = new_ael(PREFERENCE);
				new_section(p_config_file, prefer_list,
				    WIFI_PREFER);
			} else {
				(void) fprintf(stderr, gettext("%s: "
				    "%s : duplicated %s section\n"),
				    gExecName, pfile, WIFI_PREFER);
				goto error;
			}
		} else if (strstr(buf_line, WIFI_HISTORY) == buf_line) {
			if (history_list == NULL) {
				cur_list = HISTORY;
				history_list = new_ael(HISTORY);
				new_section(p_config_file, history_list,
				    WIFI_HISTORY);
			} else {
				(void) fprintf(stderr, gettext("%s: "
				    "%s : duplicated %s section\n"),
				    gExecName, pfile, WIFI_HISTORY);
				goto error;
			}
		} else if (strstr(buf_line, WIFI_ACTIVEP) == buf_line) {
			if (activep_list == NULL) {
				cur_list = ACTIVEP;
				activep_list = new_ael(ACTIVEP);
				new_section(p_config_file, activep_list,
				    WIFI_ACTIVEP);
			} else {
				(void) fprintf(stderr, gettext("%s: "
				    "%s : duplicated %s section\n"),
				    gExecName, pfile, WIFI_ACTIVEP);
				goto error;
			}
		} else if ((strchr(buf_line, '[') == buf_line) &&
		    (buf_line[strlen(buf_line) - 1] == ']')) {
			cur_list = PROFILE;
			profile_list = new_ael(PROFILE);
			new_section(p_config_file, profile_list,
			    buf_line);
		} else {
			switch (cur_list) {
			case PREFERENCE:
				if (prefer_list->ael_argc <=
				    MAX_PREFERENCE_NUM)
					new_ae(prefer_list, buf_line);
				break;
			case HISTORY:
				if (history_list->ael_argc <=
				    MAX_HISTORY_NUM)
					new_ae(history_list, buf_line);
				break;
			case ACTIVEP:
				if ((activep_list->ael_argc <= 1) &&
				    (strpbrk(buf_line, "=") != NULL))
					new_ae(activep_list, buf_line);
				break;
			case PROFILE:
				if (strpbrk(buf_line, "=") != NULL)
					new_ae(profile_list, buf_line);
				break;
			default:
				(void) fprintf(stderr,
				    gettext("%s: %s: file format error\n"),
				    gExecName, pfile);
				goto error;
			}
		}
	}
	PRTDBG(("parse_file(\"%s\")=0x%x\n", pfile, p_config_file));
	(void) fclose(file);
	return (p_config_file);
error:
	destroy_config(p_config_file);
	(void) fclose(file);
error1:
	return (NULL);
}
/*
 * construct an argument vector from an aelist
 */
static char **
aeltoargv(aelist_t *ael, int *ael_num)
{
	ae_t *ae = NULL;
	char **argv = NULL;
	int argc = 0;

	PRTDBG(("aeltoargv(%x)\n", ael));
	assert(ael != NULL);

	argv = safe_calloc(sizeof (*argv), ael->ael_argc);

	for (argc = 0, ae = ael->ael_head; ae; ae = ae->ae_next) {
		/* skip bssid since it can not be set */
		if (strncmp(ae->ae_arg, "bssid=", strlen("bssid=")) == 0)
			continue;
		argv[argc] = safe_strdup(ae->ae_arg);
		argc++;
		if (ae == ael->ael_tail)
			break;
	}

	PRTDBG(("aeltoargv(0x%x) = 0x%x\n\n", ael, argv));
	*ael_num = argc;
	return (argv);
}

/*
 * archived contents into a file
 */
static boolean_t
fprint_config_file(config_file_t *p_config_file, const char *file_name)
{
	FILE *file = NULL;
	int fd = 0;
	int len;
	section_t *p_section = NULL;
	aelist_t *p_list = NULL;
	ae_t *pae = NULL;
	char temp_file[256];
	struct stat buf;

	PRTDBG(("fprint_config_file(0x%x, \"%s\")\n", p_config_file,
			file_name));
	assert((p_config_file != NULL)&&(strcmp(file_name, "") != 0));

	safe_snprintf(temp_file, sizeof (temp_file),
	    "%s.tmp", file_name);
	fd = open(temp_file, O_CREAT|O_WRONLY|O_TRUNC, 0600);
	if (fd < 0) {
		(void) fprintf(stderr, gettext("%s: failed to open %s\n"),
		    gExecName, temp_file);
		return (B_FALSE);
	}
	file = fdopen(fd, "w");

	p_section = p_config_file->section_head;
	while (p_section != NULL) {
		p_list = p_section->list;
		if (p_list != NULL) {
			PRTDBG(("fprint_config_file: section_id=%s\n",
			    p_section->section_id));
			len = fprintf(file, "\n%s\n", p_section->section_id);
			if (len < 0) {
				(void) fprintf(stderr, gettext("%s: "
				    "failed to update %s: %s\n"),
				    gExecName, file_name, strerror(errno));
				safe_fclose(file);
				return (B_FALSE);
			}
			pae = p_list->ael_head;
			while (pae != NULL) {
				if (pae->ae_arg != NULL) {
					len = fprintf(file, "%s\n",
					    pae->ae_arg);
					if (len < 0) {
						(void) fprintf(stderr,
						    gettext("%s: failed to "
						    "update %s: %s\n"),
						    gExecName, file_name,
						    strerror(errno));
						safe_fclose(file);
						return (B_FALSE);
					}
				}
				pae = pae->ae_next;
			}
		}
		p_section = p_section->section_next;
	}
	safe_fclose(file);
	/*
	 * The attribute of the file /etc/inet/wifi and
	 * /etc/inet/security/wifiwepkey should be retained.
	 * if those file do not exist, set default file mode.
	 */
	if (stat(file_name, &buf) != 0) {
		if (errno == ENOENT) {
			buf.st_mode = 0600;
		} else {
			(void) fprintf(stderr, gettext("%s: failed to get "
			    "file %s stat: %s\n"),
			    gExecName, file_name, strerror(errno));
			return (B_FALSE);
		}
	}
	if (rename(temp_file, file_name) != 0) {
		(void) fprintf(stderr, gettext("%s: failed to update %s: %s"
		    "\n"), gExecName, file_name, strerror(errno));
		return (B_FALSE);
	}
	(void) chmod(file_name, buf.st_mode);
	return (B_TRUE);
}
/*
 * append_pa: Each section holds a section_id which identifies a section
 * a profile uses its essid appending "[]" to denote its section_id.
 * note: new memory is allocated, remember to free.
 */
static char *
append_pa(const char *arg)
{
	char *pbuf = NULL;
	int len;

	assert(arg != NULL);

	len = strlen(arg) + 3;
	pbuf = safe_malloc(len);
	safe_snprintf(pbuf, len, "[%s]", arg);
	PRTDBG(("append_pa(\"%s\") = \"%s\"\n", arg, pbuf));
	return (pbuf);
}
/*
 * find a section by section_id from p_config_file,
 * return the section pointer.
 */
static section_t *
find_section(config_file_t *p_config_file, const char *section_id)
{
	section_t *p_section = NULL;

	PRTDBG(("find_section(0x%x, \"%s\")\n", p_config_file, section_id));
	assert((section_id != NULL)&&(p_config_file != NULL));

	p_section = p_config_file->section_head;

	while (p_section != NULL) {
		if ((p_section->section_id != NULL) &&
		    (strcmp(p_section->section_id, section_id) == 0))
			return (p_section);
		p_section = p_section->section_next;
	}
	return (NULL);
}

/*
 * get_value: Get rid of "parameter=" from a "parameter=value", for example:
 * when we read an line from file, we gets "essid=ap7-2", this function
 * returns the pointer to string "ap7-2";
 */

static const char *
get_value(const char *arg)
{
	char *p;
	assert(arg != NULL);

	p = strchr(arg, '=');
	PRTDBG(("get_value(\"%s\") = \"%s\"\n", arg, p + 1));
	if (p != NULL)
		return (p + 1);
	else
		return (NULL);
}

/*
 * search /dev/wifi to see which interface is available
 */
static boolean_t
search_interface(char *interface)
{
	DIR *dirp;
	struct dirent *dp;
	char buf[256];
	int fd;

	PRTDBG(("search interface\n"));
	assert(interface != NULL);

	/*
	 * Try to return the first found wifi interface.
	 * If no wifi interface is available, return B_FALSE
	 */

	if ((dirp = opendir("/dev/wifi")) == NULL) {
		PRTDBG(("failed to open '/dev/wifi'\n"));
		return (B_FALSE);
	}
	while ((dp = readdir(dirp)) != NULL) {
		if (strcmp(dp->d_name, ".") == 0 ||
		    strcmp(dp->d_name, "..") == 0)
			continue;
		if (dp->d_name[strlen(dp->d_name) - 1] < '0' ||
		    dp->d_name[strlen(dp->d_name) - 1] > '9')
			continue;
		safe_snprintf(buf, sizeof (buf), "%s%s",
		    "/dev/wifi/", dp->d_name);
		fd = open(buf, O_RDWR);
		if (fd == -1) {
			PRTDBG(("interface %s doesn't exist\n", dp->d_name));
			continue;
		} else {
			PRTDBG(("interface %s is the first found interface\n",
			    dp->d_name));
			(void) strlcpy(interface, buf, LIFNAMSIZ);
			(void) close(fd);
			(void) closedir(dirp);
			return (B_TRUE);
		}
	}

	PRTDBG(("failed to find available wireless interface\n"));
	(void) closedir(dirp);
	return (B_FALSE);

}
/*
 * open_dev: Open the driver.
 * if the 'devname' has format like 'ath0', we should add the path to that
 * device(/dev/ath0) and open it; if the 'devname' has format like
 * '/dev/wifi/ath0', we open it directly.
 */
static int
open_dev(char *devname)
{
	int fd;
	int len;
	char *pbuf = NULL;

	PRTDBG(("open_dev(\"%s\")\n", devname));
	assert(devname != NULL);
	/*
	 * If the devname is got from the user input, we
	 * add '/dev/' to that relative devname. If it
	 * is got from the 'search interface', it is an
	 * absolute path.
	 */
	if (strncmp(devname, "/dev/wifi/", strlen("/dev/wifi/")) == 0) {
		pbuf = safe_strdup(devname);
	} else {
		len = strlen(devname) + strlen("/dev/") + 1;
		pbuf = safe_malloc(len);
		safe_snprintf(pbuf, len, "/dev/%s", devname);
	}
	fd = open(pbuf, O_RDWR);
	free(pbuf);

	if (fd == -1) {
		(void) fprintf(stderr, gettext("%s: failed to open '%s': %s"
		    "\n"), gExecName, devname, strerror(errno));
		return (-1);
	}
	if (!isastream(fd)) {
		(void) fprintf(stderr, gettext("%s: %s is "
		    "not a stream device\n"),
		    gExecName, devname);
		(void) close(fd);
		return (-1);
	}
	return (fd);
}
/*
 * call_ioctl: Fill strioctl structure and issue an ioctl system call
 */
static boolean_t
call_ioctl(int fd, int cmd, uint32_t params, uint32_t buf_len)
{
	struct strioctl stri;

	PRTDBG(("call_ioctl_gs(%d, 0x%x, 0x%x, 0x%x)\n",
	    fd, cmd, params, buf_len));

	switch (cmd) {
	case WLAN_GET_PARAM:
		(void) memset(gbuf, 0, MAX_BUF_LEN);
		stri.ic_len = MAX_BUF_LEN;
		break;
	case WLAN_SET_PARAM:
		gbuf->wldp_length = buf_len + WIFI_BUF_OFFSET;
		stri.ic_len = gbuf->wldp_length;
		break;
	case WLAN_COMMAND:
		gbuf->wldp_length = sizeof (wldp_t);
		stri.ic_len = gbuf->wldp_length;
		break;
	default:
		(void) fprintf(stderr, gettext("%s: ioctl : "
		    "unsupported ioctl command\n"), gExecName);
		return (B_FALSE);
	}
	gbuf->wldp_type = NET_802_11;
	gbuf->wldp_id = params;

	stri.ic_cmd = cmd;
	stri.ic_timout = 0;
	stri.ic_dp = (char *)gbuf;

	if (ioctl(fd, I_STR, &stri) == -1) {
		gbuf->wldp_result = 0xffff;
		return (B_FALSE);
	}
	if (cmd == WLAN_COMMAND) {
		return (B_TRUE);
	} else {
		return (gbuf->wldp_result != WL_SUCCESS ?
			B_FALSE:B_TRUE);
	}
}

/*
 * del_prefer: Delete an item from the {preferrence} list, the idea is
 * simply free the ae_t element, and set ae_arg to NULL, then when archive
 * the config_file_t struct to the file, it will be delete.
 * The last flag is used to identify whether this function is invoked due to
 * the 'removeprefer' subcommand or due to 'deleteprofile' subcommand.
 */
static boolean_t
del_prefer(config_file_t *p_config_file, const char *prefer, boolean_t rflag)
{
	section_t *p_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;
	int i = 0, position = 0;
	int number;
	ae_t *prm_ae = NULL;

	PRTDBG(("del_prefer(0x%x, \"%s\")\n", p_config_file, prefer));
	assert((prefer != NULL)&&(p_config_file != NULL));

	p_section = find_section(p_config_file, WIFI_PREFER);
	if (p_section != NULL)
		plist = p_section->list;

	if ((p_section == NULL) || (plist == NULL))
		return (B_FALSE);

	number = plist->ael_argc;
	pae = plist->ael_head;
	prm_ae = plist->ael_head;
	while (pae != NULL) {
		if (strcmp(prefer, pae->ae_arg) == 0) {
			free(pae->ae_arg);
			pae->ae_arg = NULL; /* mark */
			if (!position) {
				plist->ael_head = pae->ae_next;
				if (pae->ae_next == NULL)
					plist->ael_tail = NULL;
			} else {
				for (i = 0; i < position - 1; i++)
					prm_ae = prm_ae->ae_next;
				prm_ae->ae_next = pae->ae_next;
				if (pae->ae_next == NULL)
					plist->ael_tail = prm_ae;
			}
			free(pae);
			pae = NULL;
			plist->ael_argc--;
			break;
		}
		position++;
		pae = pae->ae_next;
	}
	if ((number == plist->ael_argc) && (rflag == B_TRUE)) {
		(void) fprintf(stderr, gettext("%s: removeprefer : "
		    "no such profile: '%s' in the preference list\n"),
		    gExecName, prefer);
		return (B_FALSE);
	}
	return (B_TRUE);
}

/*
 * del_section: Delete an section from p_config_file, the idea is
 * simply free the aelist_t struct and set it to NULL, when archiving
 * config_file_t struct to the file, we will find section list is NULL,
 * and will not write it to file, so it will be deleted.
 */
static boolean_t
del_section(config_file_t *p_config_file, char *section_id)
{
	section_t *p_section = NULL;
	section_t *prm_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;
	int i = 0, position = 0;

	PRTDBG(("del_section(0x%x, \"%s\")\n", p_config_file, section_id));
	PRTDBG(("del_section: %d section(s) in config file\n",
	    p_config_file->section_argc));
	assert((section_id != NULL)&&(p_config_file != NULL));

	if (find_section(p_config_file, section_id) == NULL) {
		return (B_FALSE);
	}
	p_section = p_config_file->section_head;
	prm_section = p_config_file->section_head;
	while (p_section != NULL) {
		if (p_section->section_id != NULL) {
			if (strcmp(p_section->section_id, section_id) == 0) {
				plist = p_section->list;
				pae = plist->ael_head;
				while (pae != NULL) {
					free(pae->ae_arg);
					pae->ae_arg = NULL;
					pae = pae->ae_next;
					free(plist->ael_head);
					plist->ael_head = pae;
				}
				free(plist);
				p_section->list = NULL;
				free(p_section->section_id);
				p_section->section_id = NULL;

				if (!position) {
					p_config_file->section_head =
					    p_section->section_next;
					if (p_section->section_next == NULL)
						p_config_file->section_tail =
						    NULL;
				} else {
					for (i = 0; i < position - 1; i++) {
						prm_section =
						    prm_section->section_next;
					}
					prm_section->section_next =
					    p_section->section_next;
					if (p_section->section_next == NULL)
						p_config_file->section_tail =
						    prm_section;
				}
				free(p_section);
				p_config_file->section_argc--;
				break;
			}
			position++;
		}
		p_section = p_section->section_next;
	}
	return (B_TRUE);
}

/*
 * set_prefer: Reorder the preferrence list.
 */
static boolean_t
set_prefer(config_file_t *p_config_file, const char *prefer, int rank)
{
	char *pbuf = NULL;
	aelist_t *plist = NULL;
	section_t *p_section = NULL;
	ae_t *pae = NULL;
	int i = 0, position = 0;
	ae_t *pae_move = NULL;

	assert(prefer != NULL);
	PRTDBG(("set_prefer(0x%x, \"%s\", %d)\n", p_config_file, prefer, rank));

	pbuf = append_pa(prefer);
	if (find_section(p_config_file, pbuf) == NULL) {
		(void) fprintf(stderr, gettext("%s: setprefer: "
		    "no such profile: '%s'\n"),
		    gExecName, prefer);
		free(pbuf);
		return (B_FALSE);
	}
	free(pbuf);

	p_section = find_section(p_config_file, WIFI_PREFER);

	if (p_section == NULL) {
		plist = new_ael(PREFERENCE);
		new_section(p_config_file, plist, WIFI_PREFER);
		new_ae(plist, prefer);
		return (B_TRUE);
	} else {
		plist = p_section->list;
	}

	pae = plist->ael_head;
	pae_move = plist->ael_head;
	while (pae != NULL) {
		if (strcmp(prefer, pae->ae_arg) == 0) {
			free(pae->ae_arg);
			pae->ae_arg = NULL;
			if (!position) {
				plist->ael_head = pae->ae_next;
				if (pae->ae_next == NULL)
					plist->ael_tail = NULL;
			} else {
				for (i = 0; i < position - 1; i++)
					pae_move = pae_move->ae_next;
				pae_move->ae_next = pae->ae_next;
				if (pae->ae_next == NULL)
					plist->ael_tail = pae_move;
			}
			free(pae);
			plist->ael_argc--;
			break;
		}
		position++;
		pae = pae->ae_next;
	}
	PRTDBG(("set_prefer: %d Profiles in prefer list\n", plist->ael_argc));
	if (rank > plist->ael_argc) {
		new_ae(plist, prefer);
	} else if (rank <= 1) {
		pae = safe_calloc(sizeof (ae_t), 1);
		pae->ae_arg = safe_strdup(prefer);
		pae->ae_next = plist->ael_head;
		plist->ael_head = pae;
		plist->ael_argc++;
	} else {
		pae_move = plist->ael_head;
		for (i = 1; i < rank-1; i++) {
			pae_move = pae_move->ae_next;
		}
		pae = safe_calloc(sizeof (ae_t), 1);
		pae->ae_arg = safe_strdup(prefer);
		pae->ae_next = pae_move->ae_next;
		pae_move->ae_next = pae;
		plist->ael_argc++;
	}
	/*
	 * If number of prefer list items is larger than the MAX_PREFERENCE_NUM
	 * delete those items whose No is larger than MAX_PREFERENCE_NUM.
	 */
	if (plist->ael_argc > MAX_PREFERENCE_NUM) {
		pae = plist->ael_head;
		while (pae->ae_next != plist->ael_tail)
			pae = pae->ae_next;
		free(plist->ael_tail->ae_arg);
		plist->ael_tail->ae_arg = NULL;
		free(plist->ael_tail);
		plist->ael_tail = pae;
		plist->ael_tail->ae_next = NULL;
		plist->ael_argc--;
	}
	PRTDBG(("set_prefer: %d Profiles in prefer list\n", plist->ael_argc));
	return (B_TRUE);
}
/*
 * add_to_history: Save the scanlist argv into history section
 */
static void
add_to_history(config_file_t *p_config_file, int argc, char **argv)
{
	int i = 0, j = 0, pos = 0;
	aelist_t *plist = NULL;
	section_t *p_section = NULL;
	ae_t *pae = NULL;
	ae_t *pae_m = NULL;
	char item[256];
	time_t cltime;

	PRTDBG(("add_to_history(0x%x, %d, 0x%x)\n", p_config_file, argc, argv));
	assert(p_config_file != NULL);

	p_section = find_section(p_config_file, WIFI_HISTORY);

	if (p_section == NULL) {
		plist = new_ael(HISTORY);
		new_section(p_config_file, plist, WIFI_HISTORY);
	} else {
		plist = p_section->list;
	}

	if (plist != NULL) {
		for (i = 0; i < argc; i++) {
			if (!strlen(argv[i]))
				continue;
			pos = 0;
			pae = plist->ael_head;
			pae_m = plist->ael_head;
			/*
			 * add time stamp to the history record
			 */
			cltime = time(&cltime);
			(void) snprintf(item, sizeof (item), "%s%c%ld",
			    argv[i], ',', cltime);
			while (pae != NULL) {
				if (strncmp(item, pae->ae_arg,
				    strlen(argv[i])) == 0) {
					free(pae->ae_arg);
					pae->ae_arg = NULL;
					if (!pos) {
						plist->ael_head = pae->ae_next;
						if (pae->ae_next == NULL)
							plist->ael_tail = NULL;
					} else {
						for (j = 0; j < pos - 1; j++)
							pae_m = pae_m->ae_next;
						pae_m->ae_next = pae->ae_next;
						if (pae->ae_next == NULL)
							plist->ael_tail = pae_m;
					}
					free(pae);
					plist->ael_argc--;
					break;
				}
				pos++;
				pae = pae->ae_next;
			}
			new_ae(plist, item);
		}

		if (plist->ael_argc > MAX_HISTORY_NUM) {
			for (i = 0; i < plist->ael_argc - MAX_HISTORY_NUM;
			    i++) {
				pae = plist->ael_head;
				free(pae->ae_arg);
				plist->ael_head = pae->ae_next;
				free(pae);
			}
			plist->ael_argc = MAX_HISTORY_NUM;
		}
	}
}

static void
do_print_usage()
{
	(void) fprintf(stderr, gettext("\t%s [-R root_path][-i interface]"
	    " autoconf [wait={n|forever}]\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path][-i interface]"
	    " connect profile [wait={n|forever}]\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path][-i interface]"
	    " connect essid [wait={n|forever}]\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path][-i interface]"
	    " disconnect\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path][-i interface]"
	    " getparam [parameter [...]]\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path][-i interface]"
	    " setparam [parameter=value [...]]\n"), gExecName);
	(void) fprintf(stderr, gettext(
		"\tparameters:\n"
		"\t\tbssid\t\t - read only: 6 byte mac address of "
		"base station\n"
		"\t\tessid\t\t - name of the network, a string of up "
		"to 32 chars\n"
		"\t\tbsstype\t\t - bss(ap, infrastructure), ibss(ad-hoc)"
		" or auto\n"
		"\t\tcreateibss\t - flag to identify whether a ibss is to be\n"
		"\t\t\t\t   created when the network to connect is\n"
		"\t\t\t\t   not available, yes or no\n"
		"\t\tchannel\t\t - channel(used only when creating an ibss)\n"
		"\t\t\t\t   valid value:\n"
		"\t\t\t\t\t 802.11a: 0-99\n"
		"\t\t\t\t\t 802.11b: 1-14\n"
		"\t\t\t\t\t 802.11g: 1-14\n"
		"\t\trates\t\t - set of rates, seperated by ',' valid rates:\n"
		"\t\t\t\t   1,2,5.5,6,9,11,12,18,22,24,33,36,48 and 54\n"
		"\t\tpowermode\t - off, mps or fast\n"
		"\t\tauthmode\t - opensystem or shared_key\n"
		"\t\tencryption\t - none or wep\n"
		"\t\twepkey|1-4\t - write only:\n"
		"\t\t\t\t   5 chars or 10 hex digits for 40bit wepkey;\n"
		"\t\t\t\t   13 chars or 26 hex digits for 128bit wepkey\n"
		"\t\twepkeyindex\t - an integer within the range 1-4\n"
		"\t\tsignal\t\t - read only: signal strength from 0 to 15\n"
		"\t\tradio\t\t - on or off\n"));
	(void) fprintf(stderr, gettext("\t%s [-R root_path][-i interface]"
	    " restoredef\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path][-i interface]"
	    " scan\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path][-i interface]"
	    " showstatus\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path][-i interface]"
	    " setwepkey 1|2|3|4\n"), gExecName);

	(void) fprintf(stderr, "\n");

	(void) fprintf(stderr, gettext("\t%s [-R root_path]"
	    " createprofile profile parameter=value [...]\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path]"
	    " deleteprofile profile1 [profile2 [...]]\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path]"
	    " showprofile profile1 [profile2 [...]]\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path]"
	    " setprofilewepkey profile 1|2|3|4\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path]"
	    " getprofileparam profile [parameter [...]]\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path]"
	    " setprofileparam profile [parameter=value [...]]\n"), gExecName);

	(void) fprintf(stderr, "\n");

	(void) fprintf(stderr, gettext("\t%s [-R root_path]"
	    " history\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path]"
	    " listprefer\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path]"
	    " removeprefer profile\n"), gExecName);
	(void) fprintf(stderr, gettext("\t%s [-R root_path]"
	    " setprefer profile [n]\n"), gExecName);
}

/*
 * do_print_support_params: Query interface which cmd is supported
 */
static boolean_t
do_print_support_params(int fd)
{
	int i = 0, n = 0;

	PRTDBG(("do_print_support_params(\"%d\")\n", fd));
	assert(fd != -1);

	(void) printf(gettext("\t  parameter\tproperty\n"));
	for (i = 0; i < N_GS_FUNC; i++) {
		gbuf->wldp_result = WL_LACK_FEATURE;
		if ((do_gs_func[i].p_do_get_func != NULL) &&
		    (do_gs_func[i].p_do_get_func(fd) != B_TRUE)) {
				continue;
		}
		if (gbuf->wldp_result == WL_SUCCESS) {
			(void) printf("\t%11s", do_gs_func[i].cmd);
			if (do_gs_func[i].rw == RO)
				(void) printf(gettext("\tread only\n"));
			else
				(void) printf(gettext("\tread/write\n"));
			n++;
		}
	}

	return (n ? B_TRUE : B_FALSE);
}

/*
 * check_authority: Check if command is permitted.
 */
static boolean_t
check_authority(wifi_auth_t type)
{
	struct passwd *pw = NULL;

	PRTDBG(("check_authority()\n"));

	pw = getpwuid(getuid());
	if (pw == NULL)
		return (B_FALSE);
	if (chkauthattr(p_auth_string[type], pw->pw_name) == 0) {
		if (type == AUTH_WEP)
			(void) fprintf(stderr, gettext("%s: "
			    "privilege '%s' is required for setting "
			    "wepkey.\n"), gExecName, WIFI_WEP_AUTH);
		else
			(void) fprintf(stderr, gettext("%s: "
			    "privilege '%s' is required.\n"),
			    gExecName, WIFI_CONFIG_AUTH);
		return (B_FALSE);
	} else {
		return (B_TRUE);
	}
}

/*
 * construct the 'history' and 'scan' output format
 * memory allocated. need to free after the function is invoked.
 */
static char *
construct_format(uint32_t nt)
{
	char *format;
	int len = 0, i;

#define	FORMAT_LEN 256
	assert((nt >= 1) && (nt <= 4));
	format = safe_malloc(FORMAT_LEN);

	for (i = 0; i < nt; i++)
		len += snprintf(format + len, FORMAT_LEN - len, "\t");
	if ((len <= 0) || (len > FORMAT_LEN - 1)) {
		return ("\t\t\t\t");
	}
	return (format);
}

/*
 * find the essid of the named profile.
 * gp_config_file is golable, so the return is gloable too.
 */
static const char *
essid_of_profile(const char *profile)
{
	section_t *p_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;
	char *pbuf;

	PRTDBG(("essid_of_profile: profile = %s\n", profile));
	pbuf = append_pa(profile);
	p_section = find_section(gp_config_file, pbuf);
	free(pbuf);

	if (p_section == NULL) {
		return (NULL);
	} else {
		plist = p_section->list;
	}
	pae = plist->ael_head;
	while (pae != NULL) {
		if (strncmp(pae->ae_arg, "essid=", strlen("essid=")) == 0) {
			PRTDBG(("essid_of_profile: essid = %s\n",
			    pae->ae_arg));
			return (get_value(pae->ae_arg));
		}
		pae = pae->ae_next;
	}
	return (NULL);
}

/*
 * If we don't know which profile is our favorate in 'autoconf',
 * we select the wifi network based on the following heuristic
 * 1. the network without wep.
 * 2. the network with the strongst signal.
 * 3. the network with the faster speed(not implemented since signal affects
 * the speed in some degree).
 */
static void
heuristic_load(int fd, uint32_t ess_num, wl_ess_conf_t **p_ess_conf)
{
	int i = 0;
	char *flag = NULL;
	int have_nowep_wlan = 0;
	wl_rssi_t maxsignal = 0;
	char essid[34];
	int timeout = LOADPROFILE_TIMEOUT;

	PRTDBG(("heuristic_load: enter\n"));
	(void) call_ioctl(fd, WLAN_COMMAND, WL_LOAD_DEFAULTS, 0);
	flag = calloc(sizeof (char), ess_num);
	for (i = 0; i < ess_num; i++) { /* extract none-wep network */
		if (p_ess_conf[i]->wl_ess_conf_wepenabled == B_FALSE) {
			flag[i] = 1;
			have_nowep_wlan = 1;
		}
	}
	/*
	 * if all the wlans are weped, we select the one with strongest signal
	 * in all of them, otherwise we just select in the none weped ones.
	 */
	if (!have_nowep_wlan)
		(void) memset(flag, 1, ess_num);
	for (i = 0; i < ess_num; i++) { /* extract the strongest signal ones */
		if (flag[i] == 1) {
			if (p_ess_conf[i]->wl_ess_conf_sl > maxsignal) {
				maxsignal = p_ess_conf[i]->wl_ess_conf_sl;
				(void) memset(flag, 0, i);
			} else if (p_ess_conf[i]->wl_ess_conf_sl == maxsignal)
				continue;
			else
				flag[i] = 0;
		}
	}
	for (i = 0; i < ess_num; i++) {
		if (flag[i] == 1)
			break;
	}
	free(flag);
	PRTDBG(("heuristic_load: %s is selected\n",
	    p_ess_conf[i]->wl_ess_conf_essid.wl_essid_essid));
	/* select one in all the networks which meet the preceding stardands */
	if (i == ess_num)
		(void) do_set_essid(fd, "");
	else
		(void) do_set_essid(fd,
		    p_ess_conf[i]->wl_ess_conf_essid.wl_essid_essid);

	if ((ess_num == 0) || (do_get_essid(fd) == B_FALSE)) {
		(void) fprintf(stderr, gettext("%s: autoconf:"
		    " failed to connect to any essid\n"),
		    gExecName);
		exit(WIFI_MINOR_ERR);
	}
	(void) strlcpy(essid, ((wl_essid_t *)(gbuf->wldp_buf))->wl_essid_essid,
	    sizeof (essid));
	(void) printf(gettext("%s: autoconf: essid '%s' is selected%s\n"),
	    gExecName, essid,
	    have_nowep_wlan ? "" : ": this is a WEPed "
	    "access point");

	if (!have_nowep_wlan)
		exit(WIFI_FATAL_ERR);

	while (timeout > 0) {
		if ((do_get_linkstatus(fd) == B_TRUE) &&
		    (*(wl_linkstatus_t *)(gbuf->wldp_buf) == WL_CONNECTED)) {
			(void) printf(gettext("%s: connecting to "
			    "essid '%s'\n"), gExecName, essid);
			return;
		}
		(void) sleep(1);
		timeout--;
	}
	(void) fprintf(stderr, gettext("%s: failed to connect to "
	    "essid '%s'\n"), gExecName, essid);
	exit(WIFI_FATAL_ERR);
}

/*
 * Called in autoconf and startconf to find which 'profile' is selected.
 * The process is: check profile names in the prefer list item by item,
 * if the essid of the profile is in the scan list, then it is the wanted.
 * readonly: 1 for startconf
 *           0 for autoconf
 * for autoconf, the scan result will be recorded in the history list.
 */
static char *
select_profile(int fd, int readonly, int timeout)
{
	uint32_t ess_num = 0;
	int nprefer = 1;
	char **ess_argv;
	char **hisess_argv;
	wl_ess_conf_t **p_ess_conf;
	section_t *p_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;
	int i;
	const char *parg;
	char *selected = NULL;
	boolean_t flag = B_FALSE;

	if ((call_ioctl(fd, WLAN_COMMAND, WL_SCAN, 0) == B_FALSE) ||
	    (do_get_wlanlist(fd) == B_FALSE)) {
		(void) fprintf(stderr, gettext("%s: "
		    "autoconf : failed to scan\n"), gExecName);
		exit(WIFI_FATAL_ERR);
	}
	ess_num = ((wl_ess_list_t *)(gbuf->wldp_buf))->wl_ess_list_num;
	ess_argv = safe_calloc(sizeof (char *), ess_num);
	hisess_argv = safe_calloc(sizeof (char *), ess_num);
	p_ess_conf = safe_calloc(sizeof (wl_ess_list_t *), ess_num);
	for (i = 0; i < ess_num; i++) {
		p_ess_conf[i] = ((wl_ess_list_t *)gbuf->wldp_buf)
		    ->wl_ess_list_ess + i;
		ess_argv[i] = safe_malloc(MAX_SCANBUF_LEN);
		if (readonly == 0) {
			hisess_argv[i] = safe_malloc(MAX_SCANBUF_LEN);
			(void) snprintf(hisess_argv[i], MAX_SCANBUF_LEN,
			    "%s%c%02x:%02x:%02x:%02x:%02x:%02x%c%s",
			    p_ess_conf[i]->wl_ess_conf_essid.wl_essid_essid,
			    ',',
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[0]),
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[1]),
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[2]),
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[3]),
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[4]),
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[5]), ',',
			    (p_ess_conf[i]->wl_ess_conf_wepenabled == B_TRUE
			    ?  "wep":"none"));
		}
		(void) snprintf(ess_argv[i], MAX_SCANBUF_LEN, "%s",
		    p_ess_conf[i]->wl_ess_conf_essid.wl_essid_essid);
	}
	if (readonly == 0) {
		add_to_history(gp_config_file, ess_num, hisess_argv);
		for (i = 0; i < ess_num; i++) {
			free(hisess_argv[i]);
		}
		free(hisess_argv);
	}

	p_section = find_section(gp_config_file, WIFI_PREFER);
	if (p_section == NULL) {
		if (ess_num > 0) {
			heuristic_load(fd, ess_num, p_ess_conf);
			exit(WIFI_EXIT_DEF);
		}
		goto done;
	}
	plist = p_section->list;
	assert(plist != NULL);
	if (plist != NULL) {
		nprefer = plist->ael_argc;
		if (nprefer == 0) {
			if (ess_num > 0) {
				heuristic_load(fd, ess_num, p_ess_conf);
				exit(WIFI_EXIT_DEF);
			}
			goto done;
		}
	}
	pae = plist->ael_head;
	while ((pae != NULL) && (flag != B_TRUE)) {
		parg = essid_of_profile(pae->ae_arg);
		if (parg != NULL) {
			for (i = 0; i < ess_num; i++) {
				if (strcmp(parg, ess_argv[i]) == 0) {
					selected = pae->ae_arg;
					flag = B_TRUE;
					break;
				}
			}
		}
		pae = pae->ae_next;
	}
done:
	if ((selected == NULL) && (timeout == 0)) {
		heuristic_load(fd, ess_num, p_ess_conf);
	}
	for (i = 0; i < ess_num; i++) {
		free(ess_argv[i]);
	}
	free(ess_argv);
	free(p_ess_conf);
	return (selected);
}

static boolean_t
is_waittime_valid(char *pbuf)
{
	int i;

	i = atoi(pbuf);
	if (i == -1)
		return (B_TRUE);
	for (i = 0; i < strlen(pbuf); i++) {
		if (isdigit(pbuf[i]) == 0) {
			return (B_FALSE);
		}
	}
	return (B_TRUE);
}
/*
 * do_autoconf: First scan the wlanlist, and select one essid from scan result
 * by the order in {preferrence} list. If no match, then heuristic_load;
 */
/*ARGSUSED*/
static boolean_t
do_autoconf(int fd, int argc, char **argv)
{
	const char *selected = NULL;
	int timeout = LOADPROFILE_TIMEOUT, forever = 0, len = 0;
	char *pequal, *param;
	char **ld_argv = NULL;
	boolean_t ret = B_TRUE;

	PRTDBG(("do_autoconf(%d, 0x%x)\n", argc, argv));
	assert(fd > 0);
	if (argc > 0) {
		param = safe_strdup(argv[0]);
		pequal = strchr(param, '=');
		if (pequal != NULL) {
			*pequal++ = '\0';
		} else {
			do_print_usage();
			exit(WIFI_IMPROPER_USE);
		}
		if (strcmp(param, "wait") != 0) {
			do_print_usage();
			exit(WIFI_IMPROPER_USE);
		} else {
			if (strcmp(pequal, "forever") == 0) {
				forever = 1;
			} else {
				if (is_waittime_valid(pequal) == B_FALSE) {
					(void) fprintf(stderr, gettext("%s: "
					    "invalid value %s for 'wait'\n"),
					    gExecName, pequal);
					exit(WIFI_FATAL_ERR);
				}
				if (sscanf(pequal, "%d", &timeout) != 1) {
					do_print_usage();
					exit(WIFI_IMPROPER_USE);
				}
				if (timeout == -1) {
					forever = 1;
				}
			}
		}
		free(param);
		if (argc > 1) {
			(void) fprintf(stderr, gettext("%s: trailing "
			    "useless tokens after '%s'\n"),
			    gExecName, argv[0]);
		}
	}

	while ((forever == 1) || (timeout > 0)) {
		timeout--;
		selected = select_profile(fd, 0, max(timeout, forever));
		if (selected != NULL)
			break;
		(void) sleep(1);
	}
	if (selected == NULL) {
		return (B_TRUE);
	}
	(void) printf(gettext("%s: autoconf: profile [%s]"
	    " is selected\n"), gExecName, selected);
	ld_argv = safe_calloc(sizeof (char *), argc+1);
	ld_argv[0] = safe_strdup(selected);
	if (argc > 0) {
		len = max(strlen(argv[0]), strlen("wait=forever"));
		ld_argv[1] = safe_malloc(len);
		safe_snprintf(ld_argv[1], len + 1, forever == 1 ?
		    "wait=forever" : "wait=%d", timeout);
	}
	ret = do_loadpf(fd, argc+1, ld_argv);
	free(ld_argv[0]);
	if (argc > 0) {
		free(ld_argv[1]);
	}
	free(ld_argv);
	return (ret);
}

/*
 * do_startconf: almost the same as the do_autoconf, except that doesn't
 * write file.
 */
/*ARGSUSED*/
static boolean_t
do_startconf(int fd, int argc, char **argv)
{
	int i = 0, ael_num = 0;
	section_t *p_section = NULL;
	section_t *p_wep_section = NULL;
	aelist_t *plist = NULL;
	const char *selected = NULL;
	ae_t *pae = NULL;
	char *pbuf = NULL;
	char **argvnew = NULL;

	PRTDBG(("do_startconf(%d, 0x%x)\n", argc, argv));
	assert(fd > 0);

	selected = select_profile(fd, 1, 0);
	if (selected == NULL) {
		return (B_TRUE);
	}

	(void) call_ioctl(fd, WLAN_COMMAND, WL_LOAD_DEFAULTS, 0);

	pbuf = append_pa(selected);
	p_wep_section = find_section(gp_wepkey_file, pbuf);
	p_section = find_section(gp_config_file, pbuf);
	free(pbuf);

	if (p_wep_section != NULL) {
		plist = p_wep_section->list;
		pae = plist->ael_head;
		while (pae != NULL) {
			if (pae->ae_arg != NULL)
				(void) do_set_wepkey(fd, pae->ae_arg);
			pae = pae->ae_next;
		}
	}

	if (p_section != NULL) {
		plist = p_section->list;
		if (plist->ael_argc == 0) {
			return (B_TRUE);
		}
		argvnew = aeltoargv(plist, &ael_num);
		(void) do_set(fd, ael_num, argvnew);

		for (i = 0; i < ael_num; i++)
			free(argvnew[i]);
		free(argvnew);
	}
	return (B_TRUE);
}

static char *
find_active_profile(int fd)
{
	section_t *p_section = NULL, *activep_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;
	const char *pessid = NULL, *pbssid = NULL;
	char essid[34], bssid[32];
	const char *activeprofile = NULL;

	PRTDBG(("find_active_profile: %d\n", fd));
	if (do_get_essid(fd) == B_FALSE) {
		return (NULL);
	}
	(void) strlcpy(essid, ((wl_essid_t *)(gbuf->wldp_buf))->wl_essid_essid,
	    sizeof (essid));
	if (do_get_bssid(fd) == B_FALSE) {
		return (NULL);
	}
	safe_snprintf(bssid, sizeof (bssid), "%02x:%02x:%02x:%02x:%02x:%02x",
	    ((uint8_t *)gbuf->wldp_buf)[0],
	    ((uint8_t *)gbuf->wldp_buf)[1],
	    ((uint8_t *)gbuf->wldp_buf)[2],
	    ((uint8_t *)gbuf->wldp_buf)[3],
	    ((uint8_t *)gbuf->wldp_buf)[4],
	    ((uint8_t *)gbuf->wldp_buf)[5]);
	activep_section = find_section(gp_config_file, WIFI_ACTIVEP);
	if (activep_section == NULL)
		return (NULL);
	activeprofile = get_value(activep_section->list->
	    ael_head->ae_arg);
	if (activeprofile == NULL)
		return (NULL);
	p_section = gp_config_file->section_head;
	while (p_section != NULL) {
		if (((plist = p_section->list) != NULL) &&
		    (plist->type == PROFILE) &&
		    (strcmp(p_section->section_id, activeprofile) == 0)) {
			pae = plist->ael_head;
			while (pae != NULL) {
				if (strncmp(pae->ae_arg, "essid=",
				    strlen("essid=")) == 0) {
					pessid = get_value(pae->ae_arg);
				}
				if (strncmp(pae->ae_arg, "bssid=",
				    strlen("bssid=")) == 0) {
					pbssid = get_value(pae->ae_arg);
				}
				pae = pae->ae_next;
			}
			if (pessid && pbssid &&
			    (strcmp(essid, pessid) == 0) &&
			    (strcmp(bssid, pbssid) == 0)) {
				return (p_section->section_id);
			}
		}
		p_section = p_section->section_next;
	}
	return (NULL);
}

static void
record_active_profile(char *pname, int action)
{
	section_t *p_section = NULL;
	aelist_t *plist = NULL;
	char pbuf[256];

	p_section = find_section(gp_config_file, WIFI_ACTIVEP);
	if (p_section == NULL) {
		plist = new_ael(ACTIVEP);
		new_section(gp_config_file, plist, WIFI_ACTIVEP);
	} else {
		plist = p_section->list;
	}

	if (action == RECORD_ADD) {
		assert(pname != NULL);
		safe_snprintf(pbuf, sizeof (pbuf), "activep=%s", pname);
		update_aelist(plist, pbuf);
	} else if (action == RECORD_DEL) {
		assert(pname == NULL);
		update_aelist(plist, "activep= ");
	}
}

/*
 * do_loadpf: load a profile, set related parameters both in wifi
 * and in wifiwepkey, if network name is not exist in the
 * configration files, then we clean all parameters and set essid only
 */
static boolean_t
do_loadpf(int fd, int argc, char ** argv)
{
	int i = 0, ael_num = 0;
	int timeout = LOADPROFILE_TIMEOUT, forever = 0;
	section_t *p_section = NULL;
	section_t *p_wep_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;
	char *pbuf = NULL;
	char **argvnew = NULL;
	char *connect;
	char *pequal, *param;

	PRTDBG(("do_loadpf(%d, %x)\n", argc, argv));
	assert(fd > 0);
	if (argc == 0) {
		(void) fprintf(stderr, gettext("%s: connect: "
		    "profile name missing\n"), gExecName);
		return (B_FALSE);
	}
	if (argc > 1) {
		param = safe_strdup(argv[1]);
		pequal = strchr(param, '=');
		if (pequal != NULL) {
			*pequal++ = '\0';
		} else {
			do_print_usage();
			exit(WIFI_IMPROPER_USE);
		}
		if (strcmp(param, "wait") != 0) {
			do_print_usage();
			exit(WIFI_IMPROPER_USE);
		} else {
			if (strcmp(pequal, "forever") == 0) {
				forever = 1;
			} else {
				if (is_waittime_valid(pequal) == B_FALSE) {
					(void) fprintf(stderr, gettext("%s: "
					    "invalid value %s for 'wait'\n"),
					    gExecName, pequal);
					exit(WIFI_FATAL_ERR);
				}
				if (sscanf(pequal, "%d", &timeout) != 1) {
					do_print_usage();
					exit(WIFI_IMPROPER_USE);
				}
				if (timeout == -1) {
					forever = 1;
				}
			}
		}
		free(param);
		if (argc > 2) {
			(void) fprintf(stderr, gettext("%s: trailing "
			    "useless tokens after '%s'\n"),
			    gExecName, argv[1]);
		}
	}
	(void) call_ioctl(fd, WLAN_COMMAND, WL_LOAD_DEFAULTS, 0);

	pbuf = append_pa(argv[0]);
	p_wep_section = find_section(gp_wepkey_file, pbuf);
	p_section = find_section(gp_config_file, pbuf);

	if (p_wep_section != NULL) {
		(void) set_prefer(gp_config_file, argv[0], 1);
		plist = p_wep_section->list;
		pae = plist->ael_head;
		while (pae != NULL) {
			if (pae->ae_arg != NULL) {
				(void) do_set_wepkey(fd, pae->ae_arg);
			}
			pae = pae->ae_next;
		}
	}

	if (p_section != NULL) {
		connect = "profile";

		(void) set_prefer(gp_config_file, argv[0], 1);
		plist = p_section->list;
		if (plist->ael_argc == 0) {
			free(pbuf);
			return (B_TRUE);
		}
		argvnew = aeltoargv(plist, &ael_num);
		/*
		 * if there is no 'essid' item in argvnew, the profile
		 * name(argv[0]) is treated as essid.
		 */
		for (i = 0; i < ael_num; i++) {
			if (strncmp(argvnew[i], "essid=", strlen("essid="))
			    == 0)
				break;
		}
		if (i == ael_num)
			(void) do_set_essid(fd, argv[0]);

		(void) do_set(fd, ael_num, argvnew);

		for (i = 0; i < ael_num; i++)
			free(argvnew[i]);
		free(argvnew);

		/*
		 * set flag in {active_profile} so that showprofile knows
		 * which profile is active when more than one profiles are
		 * created for the same WLAN.
		 */
		record_active_profile(pbuf, RECORD_ADD);
	} else {
		(void) do_set_essid(fd, argv[0]);
		connect = "essid";
	}

	while ((forever == 1) || (timeout > 0)) {
		if ((do_get_linkstatus(fd) == B_TRUE) &&
		    (*(wl_linkstatus_t *)(gbuf->wldp_buf) == WL_CONNECTED)) {
			section_t *p_section = NULL;
			aelist_t *plist = NULL;
			char bssid[32];
			/* record bssid in the profile */
			if (do_get_bssid(fd) == B_FALSE) {
				free(pbuf);
				return (B_TRUE);
			}
			safe_snprintf(bssid, sizeof (bssid),
			    "bssid=%02x:%02x:%02x:%02x:%02x:%02x",
			    ((uint8_t *)gbuf->wldp_buf)[0],
			    ((uint8_t *)gbuf->wldp_buf)[1],
			    ((uint8_t *)gbuf->wldp_buf)[2],
			    ((uint8_t *)gbuf->wldp_buf)[3],
			    ((uint8_t *)gbuf->wldp_buf)[4],
			    ((uint8_t *)gbuf->wldp_buf)[5]);

			p_section = find_section(gp_config_file, pbuf);
			if (p_section != NULL) {
				plist = p_section->list;
				update_aelist(plist, bssid);
			}
			free(pbuf);
			(void) printf(gettext("%s: connecting to "
			    "%s '%s'\n"), gExecName, connect, argv[0]);
			return (B_TRUE);
		}
		(void) sleep(1);
		timeout--;
		PRTDBG(("connect counting:......%d\n", timeout));
	}
	(void) fprintf(stderr, gettext("%s: failed to connect to "
	    "%s '%s'\n"), gExecName, connect, argv[0]);
	free(pbuf);
	return (B_FALSE);
}

/*
 * if wepkey is set in the profile, display wepkey|n=*****
 * when showprofile and getprofilewepkey.
 * if wepkeyn is NULL, all the wepkeys will be display,
 * otherwise, just display the matching one.
 */
static void
print_wepkey_info(const char *id, const char *wepkeyn)
{
	char *pequal, *param;
	section_t *p_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;

	p_section = find_section(gp_wepkey_file, id);
	if (p_section != NULL) {
		plist = p_section->list;
		pae = plist->ael_head;
		while (pae != NULL) {
			if (pae->ae_arg != NULL) {
				param = safe_strdup(pae->ae_arg);
				pequal = strchr(param, '=');
				if (pequal == NULL)
					return;
				*pequal = '\0';
				if (wepkeyn != NULL) {
					if (strcmp(wepkeyn, param) == 0)
						(void) printf("\t%s=*****\n",
						    param);
					free(param);
					return;
				} else {
					(void) printf("\t%s=*****\n", param);
					free(param);
				}
			}
			pae = pae->ae_next;
		}
	}
}

/*
 * do_printpf: print each parameters of the profile, if no network name
 * assigned, then print all profile saved in configration file.
 */
/*ARGSUSED*/
static boolean_t
do_printpf(int fd, int argc, char ** argv)
{
	section_t *p_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;
	char *pbuf = NULL;
	int i;

	PRTDBG(("do_printpf(%d, %x)\n", argc, argv));

	/*
	 * if no profile name is inputted, all the profiles will be displayed.
	 */
	if (argc == 0) {
		p_section = gp_config_file->section_head;
		while (p_section != NULL) {
			plist = p_section->list;
			if (plist->type == PROFILE) {
				(void) printf("%s\n", p_section->section_id);
				pae = plist->ael_head;
				while (pae != NULL) {
					if (pae->ae_arg != NULL) {
						(void) printf("\t%s\n",
						    pae->ae_arg);
					}
					pae = pae->ae_next;
				}
				/*
				 * identify whether wepkey is set
				 * in the profile
				 */
				print_wepkey_info(p_section->section_id, NULL);
			}
			p_section = p_section->section_next;
		}
		return (B_TRUE);
	}

	for (i = 0; i < argc; i++) {
		pbuf =	append_pa(argv[i]);
		p_section = find_section(gp_config_file, pbuf);
		free(pbuf);
		if (p_section != NULL)	{
			(void) printf("%s\n", p_section->section_id);
			plist = p_section->list;
			if (plist != NULL) {
				pae = plist->ael_head;
				while (pae != NULL) {
					if (pae->ae_arg != NULL) {
						(void) printf("\t%s\n",
						    pae->ae_arg);
					}
					pae = pae->ae_next;
				}
				/*
				 * identify whether wepkey is set
				 * in the profile
				 */
				print_wepkey_info(p_section->section_id, NULL);
			}
		} else {
			(void) fprintf(stderr,
				gettext("%s: showprofile : "
				    "no such profile: '%s'\n"),
				    gExecName, argv[i]);
			return (B_FALSE);
		}
	}
	return (B_TRUE);
}
/*
 * find_ae: Find an ae by its contents, return its pointer.
 */
static ae_t *
find_ae(aelist_t *plist, const char *arg)
{
	char *param = NULL;
	char *pnext = NULL;
	ae_t *pae = NULL;

	if ((arg == NULL) || (plist == NULL)) {
		PRTDBG(("find_ae: arg= NULL or plist=NULL\n"));
		return (NULL);
	}
	PRTDBG(("find_ae(0x%x, \"%s\")\n", plist, arg));
	param = safe_strdup(arg);
	pnext = strchr(param, '=');
	if (pnext != NULL) {
		*pnext = '\0';
	} else {
		PRTDBG(("find_ae: param = \"%s\"\n", param));
		free(param);
		return (NULL);
	}

	pae = plist->ael_head;
	while (pae != NULL) {
		if ((pae->ae_arg != NULL) &&
		    (strncmp(pae->ae_arg, param, strlen(param)) == 0)) {
			PRTDBG(("find_ae: param = \"%s\"\n", param));
			free(param);
			return (pae);
		}
		pae = pae->ae_next;
	}
	free(param);
	return (NULL);
}

/*
 * update_aelist: Update an aelist by arg, for example:
 * there are an item with content"essid=ap7-2",
 * update_aelist(0x..., "essid=myssid2") will update it as "essid=myssid2"
 */
static void
update_aelist(aelist_t *plist, const char *arg)
{
	ae_t *pae = NULL;

	assert((arg != NULL)&&(plist != NULL));
	PRTDBG(("update_aelist(0x%x, \"%s\")\n", plist, arg));
	pae = find_ae(plist, arg);
	if (pae == NULL) {
		new_ae(plist, arg);
	} else {
		free(pae->ae_arg);
		pae->ae_arg = safe_strdup(arg);
	}
}

/*
 * do_deletepf: delete a profile in configration files.
 */
/*ARGSUSED*/
static boolean_t
do_deletepf(int fd, int argc, char **argv)
{
	int i = 0;
	char *section_id;
	char *prefer;
	section_t *p_section = NULL, *p_sectionbak = NULL;
	aelist_t *plist = NULL;

	PRTDBG(("do_deletepf(%d, \"%s\")\n", argc, argv));
	if (argc <= 0) {
		do_print_usage();
		exit(WIFI_IMPROPER_USE);
	}

	/*
	 * if a "all" is inputted, all the profiles will be deleted.
	 */
	if (strcasecmp(argv[0], "all") == 0) {
		p_section = gp_config_file->section_head;
		while ((p_section != NULL) &&
		    ((plist = p_section->list) != NULL)) {
			if (plist->type == PROFILE) {
				p_sectionbak = p_section->section_next;
				section_id = safe_strdup(p_section->section_id);
				(void) del_section(gp_config_file, section_id);
				(void) del_section(gp_wepkey_file, section_id);
				/*
				 * remove the '[]' of the [section_id]
				 */
				prefer = section_id + 1;
				*(prefer + strlen(section_id) - 2) = '\0';
				(void) del_prefer(gp_config_file, prefer,
				    B_FALSE);
				free(section_id);
				p_section = p_sectionbak;
					continue;
			}
			p_section = p_section->section_next;
		}
		return (B_TRUE);
	}
	if (gp_config_file != NULL) {
		for (i = 0; i < argc; i++) {
			section_id = append_pa(argv[i]);
			if (del_section(gp_config_file, section_id)
			    == B_FALSE) {
				if (del_section(gp_wepkey_file, section_id)
				    == B_TRUE) {
					(void) del_prefer(gp_config_file,
					    argv[i], B_FALSE);
					free(section_id);
					return (B_TRUE);
				} else {
					(void) fprintf(stderr,
					    gettext("%s: deleteprofile"
					    ": no such profile: '%s'\n"),
					    gExecName, argv[i]);
					free(section_id);
					return (B_FALSE);
				}
			}
			(void) del_prefer(gp_config_file, argv[i], B_FALSE);
			(void) del_section(gp_wepkey_file, section_id);
			free(section_id);
		}
	}
	return (B_TRUE);
}

/*
 * do_history: Print the list in {history} section.
 */
/*ARGSUSED*/
static boolean_t
do_history(int fd, int argc, char **argv)
{
	section_t *p_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;
	char *param, *param_bak, *pcomma;
	uint32_t maxessidlen = 0, ulen;
	char format[256], *ntstr;
	uint32_t nt = 0, cnt = 0;
	int len;
	time_t cltime;

	PRTDBG(("do_history(%d, 0x%x)\n", argc, argv));
	if (argc > 0) {
		(void) fprintf(stderr, gettext("%s: trailing useless tokens "
		    "after 'history'\n"), gExecName);
	}
	p_section = find_section(gp_config_file, WIFI_HISTORY);
	if (p_section == NULL) {
		PRTDBG(("no history section\n"));
		return (B_FALSE);
	}
	plist = p_section->list;

	/*
	 * If history section is empty, directly return.
	 */
	if (plist == NULL)
		return (B_TRUE);
	/*
	 * construct the output format in terms of the
	 * maxmium essid length
	 */
	pae = NULL;
	pae = plist->ael_head;
	while (pae != NULL) {
		if (pae->ae_arg != NULL) {
			param = safe_strdup(pae->ae_arg);
			pcomma = strchr(param, ',');
			if (pcomma == NULL) {
				(void) fprintf(stderr,
				    gettext("%s: history : "
				    "data format error\n"),
				    gExecName);
				free(param);
				return (B_FALSE);
			}
			*pcomma = '\0';
			ulen = strlen(param);
			maxessidlen = (maxessidlen > ulen
			    ? maxessidlen:ulen);
			free(param);
		}
		pae = pae->ae_next;
	}
	if ((nt = (maxessidlen / 8 + 1)) > 4)
		nt = 4;
	len = snprintf(format, sizeof (format), gettext("essid"));
	ntstr = construct_format(nt);
	assert((ntstr != NULL) && (strlen(ntstr) <= 4));
	len += snprintf(format + len, sizeof (format) - len, "%s", ntstr);
	len += snprintf(format + len, sizeof (format) - len,
	    gettext("bssid\t\t  encryption\tlast seen\n"));

	if ((len <= 0) || (len > sizeof (format) - 1)) {
		(void) printf(gettext("essid\t\t\t\tbssid\t\t  encryption"
		    "\tlast seen\n"));
	} else {
		(void) printf("%s", format);
	}
	/*
	 * output the contents of the history section.
	 */
	pae = plist->ael_head;
	while (pae != NULL) {
		if (pae->ae_arg != NULL) {
			param = safe_strdup(pae->ae_arg);
			param_bak = param;
			if ((pcomma = strchr(param, ',')) != NULL) {
				*pcomma = '\0';
				cnt = nt - (min((strlen(param)/8 + 1), 4) - 1);
				ntstr = construct_format(cnt);
				assert(ntstr != NULL);
				/* display essid */
				(void) printf("%s%s", param, ntstr);
				free(ntstr);
			}
			param = pcomma + 1;
			if ((pcomma = strchr(param, ',')) != NULL) {
				*pcomma = '\0';
				/* display bssid */
				(void) printf("%s ", param);
			}
			param = pcomma + 1;
			if ((pcomma = strchr(param, ',')) != NULL) {
				*pcomma = '\0';
				/* display wep */
				(void) printf("%s\t\t", param);
			}
			param = pcomma + 1;
			/* display time stamp */
			cltime = (time_t)atol(param);
			(void) printf("%s", ctime(&cltime));
			free(param_bak);
		}
		pae = pae->ae_next;
	}

	return (B_TRUE);
}

/*
 * do_lsprefer: Print the list in {preferrence} section
 */
/*ARGSUSED*/
static boolean_t
do_lsprefer(int fd, int argc, char **argv)
{
	int i = 0;
	section_t *p_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;
	char *pbuf;

	PRTDBG(("do_lsprefer(%d, 0x%x)\n", argc, argv));
	if (argc > 0) {
		(void) fprintf(stderr, gettext("%s: trailing useless tokens "
		    "after 'listprefer'\n"), gExecName);
	}
	p_section = find_section(gp_config_file, WIFI_PREFER);
	if (p_section != NULL) {
		plist = p_section->list;
		if (plist != NULL) {
			pae = NULL;
			pae = plist->ael_head;
			while (pae != NULL) {
				if (pae->ae_arg != NULL) {
					pbuf = append_pa(pae->ae_arg);
					(void) printf("%d\t%s\n", ++i, pbuf);
				}
				pae = pae->ae_next;
			}
		}
		return (B_TRUE);
	} else {
		PRTDBG(("no preference section\n"));
		return (B_FALSE);
	}
}

/*
 * do_rmprefer: Remove an item in {preferrence} list
 */
/*ARGSUSED*/
static boolean_t
do_rmprefer(int fd, int argc, char **argv)
{
	int i = 0;
	section_t *p_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;

	PRTDBG(("do_rmprefer(%d, 0x%x)\n", argc, argv));
	if (argc <= 0) {
		do_print_usage();
		exit(WIFI_IMPROPER_USE);
	}

	/*
	 * if a "all" is inputted, all the items in the preference
	 * list will be deleted.
	 */
	if (strcasecmp(argv[0], "all") == 0) {
		p_section = find_section(gp_config_file, WIFI_PREFER);
		if (p_section != NULL)
			plist = p_section->list;

		if ((p_section == NULL) || (plist == NULL))
			return (B_FALSE);
		pae = plist->ael_head;
		while (pae != NULL) {
			free(pae);
			pae = pae->ae_next;
		}
		plist->ael_head = plist->ael_tail = NULL;
		plist->ael_argc = 0;
	} else if (gp_config_file != NULL) {
		for (i = 0; i < argc; i++) {
			if (del_prefer(gp_config_file, argv[i], B_TRUE)
			    == B_FALSE) {
				return (B_FALSE);
			}
		}
	}
	return (B_TRUE);
}

static boolean_t
is_prefer_rank_valid(const char *pbuf)
{
	int i;
	boolean_t ret = B_FALSE;

	for (i = 0; i < strlen(pbuf); i++) {
		if (isdigit(pbuf[i]) == 0) {
			ret = B_FALSE;
			goto exit0;
		}
	}
	i = atoi(pbuf);
	if ((i >= 1) && (i <= MAX_PREFERENCE_NUM))
		ret = B_TRUE;
exit0:
	return (ret);
}

/*
 * do_setprefer: Set network preferrence
 */
/*ARGSUSED*/
static boolean_t
do_setprefer(int fd, int argc, char **argv)
{
	int rank = 0;

	PRTDBG(("do_setprefer(%d, 0x%x)\n", argc, argv));
	if (argc <= 0) {
		do_print_usage();
		exit(WIFI_IMPROPER_USE);
	}
	if (argc == 1) {
		rank = 1;
	} else {
		if (is_prefer_rank_valid(argv[1]) == B_FALSE) {
			(void) fprintf(stderr, gettext("%s: preference rank "
			    "should be an integer within 1-10\n"), gExecName);
			return (B_FALSE);
		}
		rank = atoi(argv[1]);
	}
	return (set_prefer(gp_config_file, argv[0], rank));
}

static boolean_t
is_wepkeyindex_valid(const char *pbuf)
{
	int i;
	boolean_t ret = B_FALSE;

	for (i = 0; i < strlen(pbuf); i++) {
		if (isdigit(pbuf[i]) == 0) {
			ret = B_FALSE;
			goto exit0;
		}
	}
	i = atoi(pbuf);
	if ((i >= 1) && (i <= MAX_NWEPKEYS))
		ret = B_TRUE;
exit0:
	return (ret);
}

static boolean_t
is_channel_valid(const char *pbuf)
{
	int i;
	boolean_t ret = B_FALSE;

	for (i = 0; i < strlen(pbuf); i++) {
		if (isdigit(pbuf[i]) == 0) {
			ret = B_FALSE;
			goto exit0;
		}
	}
	i = atoi(pbuf);
	if ((i >= 0) && (i <= MAX_CHANNEL_NUM))
		ret = B_TRUE;
exit0:
	return (ret);
}

static boolean_t
is_wepkey_valid(const char *pbuf, uint32_t length)
{
	int i;
	boolean_t ret = B_FALSE;

	switch (length) {
	case 10:
	case 26:
		for (i = 0; i < length; i++) {
			if (isxdigit(pbuf[i]) == 0) {
				ret = B_FALSE;
				goto exit0;
			}
		}
		ret = B_TRUE;
		break;
	case 5:
	case 13:
		ret = B_TRUE;
		break;
	default:
		ret = B_FALSE;
		break;
	}
exit0:
	if (ret == B_FALSE) {
		(void) fprintf(stderr, gettext("%s: "
		    "wepkey should be:\n"
		    "\t 40bits: 5 char or 10 hex digits.\n"
		    "\t 128bits: 13 char or 26 hex digits.\n"),
		    gExecName);
	}
	return (ret);
}

/*
 * get_valid_wepkey: get an valid wepkey from stdin
 */
static char *
get_valid_wepkey()
{
	int i = 0;
	char *buf = NULL;
	uint8_t length = 0;
	struct termios stored_settings;
	struct termios new_settings;

	PRTDBG(("get_valid_wepkey()\n"));
	buf = safe_calloc(sizeof (char), MAX_KEY_LENGTH + 2);
	/*
	 * Because we need to get single char from terminal, so we need to
	 * disable canonical mode and set buffer size to 1 tyte. And because
	 * wepkey should not be see by others, so we disable echo too.
	 */
	(void) fflush(stdin);
	(void) tcgetattr(0, &stored_settings);
	new_settings = stored_settings;
	new_settings.c_lflag &= (~ICANON);
	new_settings.c_lflag &= (~ECHO);
	new_settings.c_cc[VTIME] = 0;
	new_settings.c_cc[VMIN] = 1;
	/* Set new terminal attributes */
	(void) tcsetattr(0, TCSANOW, &new_settings);
	while (((buf[i++] = getchar()) != '\n') && (i < MAX_KEY_LENGTH + 1)) {
		(void) putchar('*');
	}
	(void) putchar('\n');
	/* Restore terminal attributes */
	(void) tcsetattr(0, TCSANOW, &stored_settings);
	(void) fflush(stdin);

	if (buf[--i] != '\n') {
		(void) fprintf(stderr, gettext("%s: wepkey length "
		    "exceeds 26 hex digits\n"), gExecName);
		free(buf);
		return (NULL);
	}
	/* Replace last char '\n' with '\0' */
	buf[i] = '\0';
	length = (uint8_t)i;
	return ((is_wepkey_valid(buf, length) == B_TRUE)?
	    buf : NULL);
}

/*
 * do_set_wepkey: Set parameters in wepkey, and call ioctl
 */
static boolean_t
do_set_wepkey(int fd, const char *pbuf)
{
	int id = 0;
	char i = 0;
	uint8_t len = 0;
	uint8_t length;
	const char *wepkey = NULL;
	char key[MAX_KEY_LENGTH] = {0};
	unsigned int keytmp;
	wl_wep_key_tab_t wepkey_tab;

	PRTDBG(("do_set_wepkey(%d, \"%s\")\n", fd, pbuf));
	if (!check_authority(AUTH_WEP)) {
		exit(WIFI_FATAL_ERR);
	}
	id = pbuf[strlen("wepkeyn") - 1] - '0';
	wepkey = get_value(pbuf);
	length = strlen(wepkey);
	switch (length) {
	case 10:
	case 26:
		for (i = 0; i < length / 2; i++) {
			(void) sscanf(wepkey + i * 2, "%2x", &keytmp);
			key[i] = (char)keytmp;
		}
		len = length / 2;
		break;
	case 5:
	case 13:
		(void) strlcpy(key, wepkey, MAX_KEY_LENGTH);
		len = length;
		break;
	default:
		PRTDBG(("do_set_wepkey: error pbuf size\n"));
		(void) fprintf(stderr, gettext("%s: "
		    "wepkey should be:\n"
		    "\t 40bits: 5 char or 10 hex digits.\n"
		    "\t 128bits: 13 char or 26 hex digits.\n"),
		    gExecName);
		exit(WIFI_FATAL_ERR);
	}

	(void) memset(wepkey_tab, 0, sizeof (wepkey_tab));
	for (i = 0; i < MAX_NWEPKEYS; i++) {
		wepkey_tab[i].wl_wep_operation = WL_NUL;
	}

	if (id > 0 && id <= MAX_NWEPKEYS) {
		wepkey_tab[id-1].wl_wep_operation = WL_ADD;
		wepkey_tab[id-1].wl_wep_length = len;
		(void) memcpy(wepkey_tab[id-1].wl_wep_key, key, len);
	} else {
		(void) fprintf(stderr, gettext("%s: wepkeyindex "
		    "should be an integer within the range 1-4\n"), gExecName);
		exit(WIFI_FATAL_ERR);
	}
	(void) memmove(gbuf->wldp_buf, &wepkey_tab, sizeof (wl_wep_key_tab_t));
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_WEP_KEY_TAB,
	    sizeof (wl_wep_key_tab_t)));
}

/*
 * get the committed wepkey. the return form is like wepkey1=*****;
 */
/*ARGSUSED*/
static char *
get_commit_key(int fd, int argc, char **argv)
{
	int key;
	int len;
	char *wepkey = NULL;
	char *wepkey_confirm = NULL;
	char *pbuf = NULL;

	key = atoi(argv[0]);
	if (key <= 0 || key > MAX_NWEPKEYS) {
		(void) fprintf(stderr, gettext("%s: wepkeyindex "
		    "should be an integer within the range 1-4\n"), gExecName);
		goto exit0;
	}
	(void) printf(gettext("input wepkey%d:"), key);
	wepkey = get_valid_wepkey();
	if (wepkey == NULL) {
		goto exit0;
	}
	(void) printf(gettext("confirm wepkey%d:"), key);
	wepkey_confirm = get_valid_wepkey();
	if (wepkey_confirm == NULL) {
		free(wepkey);
		goto exit0;
	}
	if (strcmp(wepkey, wepkey_confirm) != 0) {
		free(wepkey);
		free(wepkey_confirm);
		(void) fprintf(stderr,
		    gettext("%s: wepkey: "
		    "two inputs are not identical\n"), gExecName);
		goto exit0;
	}
	free(wepkey_confirm); /* wepkey_confirm is no longer used */

	len = MAX_KEY_LENGTH + strlen("wepkey1=\n") + 1;
	pbuf = safe_malloc(len);
	safe_snprintf(pbuf, len, "%s%d=%s", "wepkey", key, wepkey);

	free(wepkey); /* wepkey is no longer used */
	return (pbuf);
exit0:
	return (NULL);
}

/*
 * do_wepkey: Get input from user, call do_set_wepkey
 */
/*ARGSUSED*/
static boolean_t
do_wepkey(int fd, int argc, char **argv)
{
	char *pbuf;

	PRTDBG(("do_wepkey(%d, 0x%x)\n", argc, argv));
	assert(fd > 0);
	if (argc <= 0) {
		do_print_usage();
		exit(WIFI_IMPROPER_USE);
	}
	if (argc > 1) {
		(void) fprintf(stderr, gettext("%s: trailing useless tokens "
		    "after 'setwepkey'\n"), gExecName);
	}
	pbuf = get_commit_key(fd, argc, argv);
	if ((pbuf != NULL) && (do_set_wepkey(fd, pbuf) == B_TRUE)) {
		free(pbuf);
		return (B_TRUE);
	}
	free(pbuf);
	return (B_FALSE);
}

/*ARGSUSED*/
static boolean_t
do_setprofwepkey(int fd, int argc, char **argv)
{
	char *pbuf;
	char *section_id = NULL;
	section_t *p_section = NULL;
	aelist_t *plist = NULL;

	PRTDBG(("do_setprofwepkey(%d, 0x%x)\n", argc, argv));
	if (argc < 2) {
		do_print_usage();
		exit(WIFI_IMPROPER_USE);
	}
	if (argc > 2) {
		(void) fprintf(stderr, gettext("%s: trailing useless tokens "
		    "after 'setprofwepkey'\n"), gExecName);
	}

	section_id = append_pa(argv[0]);
	p_section = find_section(gp_wepkey_file, section_id);
	free(section_id);
	if (p_section == NULL) {
		(void) fprintf(stderr, gettext("%s: "
		    "no such profile: '%s'\n"),
		    gExecName, argv[0]);
		return (B_FALSE);
	}

	argc--;
	argv++;
	pbuf = get_commit_key(fd, argc, argv);
	if (pbuf == NULL)
		return (B_FALSE);
	plist = p_section->list;
	update_aelist(plist, pbuf);

	return (B_TRUE);
}

/*
 * do_wlanlist: Scan for wlanlist
 */
/*ARGSUSED*/
static boolean_t
do_wlanlist(int fd, int argc, char **argv)
{
	PRTDBG(("do_wlanlist(%d, 0x%x)\n", argc, argv));
	assert(fd > 0);
	if (argc > 0) {
		(void) fprintf(stderr, gettext("%s: trailing useless tokens "
		    "after 'scan'\n"), gExecName);
	}
	if (call_ioctl(fd, WLAN_COMMAND, WL_SCAN, 0) == B_FALSE) {
		(void) fprintf(stderr, gettext("%s: failed to scan\n"),
		    gExecName);
		return (B_FALSE);
	}
	if (do_get_wlanlist(fd) == B_TRUE) {
		print_gbuf(WLANLIST);
	}
	return (B_TRUE);
}

/*
 * do_showstatus: show the basic status of the interface, including
 * linkstauts, essid, encryption and signal strength.
 */
/*ARGSUSED*/
static boolean_t
do_showstatus(int fd, int argc, char **argv)
{
	wl_rssi_t signal;
	char *active_profile = NULL;

	PRTDBG(("do_showstatus(%d, 0x%x)\n", argc, argv));
	assert(fd > 0);

	if (argc > 0) {
		(void) fprintf(stderr, gettext("%s: trailing useless tokens "
		    "after 'showstatus'\n"), gExecName);
	}
	if (do_get_linkstatus(fd) == B_TRUE) {
		print_gbuf(LINKSTATUS);
		if (*(wl_linkstatus_t *)(gbuf->wldp_buf) == WL_NOTCONNECTED) {
			return (B_TRUE);
		}
	}
	active_profile = find_active_profile(fd);
	(void) printf("\tactive profile: %s\n",
	    active_profile ? active_profile : "none");
	if (do_get_essid(fd) == B_TRUE) {
		print_gbuf(ESSID);
	}
	if (do_get_bssid(fd) == B_TRUE) {
		print_gbuf(BSSID);
	}
	if (do_get_encryption(fd) == B_TRUE) {
		print_gbuf(ENCRYPTION);
	}
	if (do_get_signal(fd) == B_TRUE) {
		signal = *(wl_rssi_t *)(gbuf->wldp_buf);
		if (signal < 4) {
			(void) printf("\tsignal strength: weak(%d)\n",
			    signal);
		} else if ((signal >= 4) && (signal <= 11)) {
			(void) printf("\tsignal strength: medium(%d)\n",
			    signal);
		} else {
			(void) printf("\tsignal strength: strong(%d)\n",
			    signal);
		}
	}

	return (B_TRUE);
}


/*
 * do_restoredef: Ask driver for loading default parameters
 */
/*ARGSUSED*/
static boolean_t
do_restoredef(int fd, int argc, char **argv)
{
	PRTDBG(("do_restoredef(%d, 0x%x)\n", argc, argv));
	assert(fd > 0);

	if (argc > 0) {
		(void) fprintf(stderr, gettext("%s: trailing useless tokens "
		    "after 'restoredef'\n"), gExecName);
	}
	record_active_profile(NULL, RECORD_DEL);
	if (call_ioctl(fd, WLAN_COMMAND, WL_LOAD_DEFAULTS, 0) == B_FALSE) {
		return (B_FALSE);
	} else {
		return (B_TRUE);
	}
}

/*
 * do_disconnect: disconnect from the current connectted network
 */
/*ARGSUSED*/
static boolean_t
do_disconnect(int fd, int argc, char **argv)
{
	PRTDBG(("do_disconnect(%d, 0x%x)\n", argc, argv));
	assert(fd > 0);

	if (argc > 0) {
		(void) fprintf(stderr, gettext("%s: trailing useless tokens "
		    "after 'disconnect'\n"), gExecName);
	}
	record_active_profile(NULL, RECORD_DEL);
	if (call_ioctl(fd, WLAN_COMMAND, WL_DISASSOCIATE, 0) == B_FALSE) {
		return (B_FALSE);
	} else {
		return (B_TRUE);
	}
}

static boolean_t
do_set_essid(int fd, const char *arg)
{
	wl_essid_t essid;

	PRTDBG(("do_set_essid(%d, \"%s\")\n", fd, arg));

	/*
	 * a trick here: clean the active_profile flag
	 * in section{active_profile}
	 */
	record_active_profile(NULL, RECORD_DEL);

	(void) memset(&essid, 0x0, sizeof (essid));

	if (arg == NULL || strcmp(arg, "") == 0) {
		essid.wl_essid_length = 0;
		essid.wl_essid_essid[0] = '\0';
	} else {
		essid.wl_essid_length = strlen(arg);
		if (essid.wl_essid_length > MAX_ESSID_LENGTH) {
			(void) fprintf(stderr, gettext("%s: "
			    "essid exceeds 32 bytes\n"), gExecName);
			exit(WIFI_FATAL_ERR);
		}
		(void) strcpy(essid.wl_essid_essid, arg);
	}
	(void) memmove(gbuf->wldp_buf, &essid, sizeof (wl_essid_t));
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_ESSID, sizeof (wl_essid_t)));
}

static boolean_t
do_set_bsstype(int fd, const char *arg)
{
	wl_bss_type_t bsstype;

	assert(arg != NULL);

	PRTDBG(("do_set_bsstype(%d, \"%s\")\n", fd, arg));

	(void) memset(&bsstype, 0xff, sizeof (bsstype));

	if ((strcasecmp(arg, "BSS") == 0) ||
	    (strcasecmp(arg, "AP") == 0) ||
	    (strcasecmp(arg, "INFRASTRUCTURE") == 0)) {
		bsstype = WL_BSS_BSS;
	} else if ((strcasecmp(arg, "IBSS") == 0) ||
	    (strcasecmp(arg, "AD-HOC") == 0)) {
		bsstype = WL_BSS_IBSS;
	} else if (strcasecmp(arg, "AUTO") == 0) {
		bsstype = WL_BSS_ANY;
	} else {
		(void) fprintf(stderr, gettext("%s: bsstype: "
		    "bss(ap,infrastructure) ibss(ad-hoc) or auto\n"),
		    gExecName);
		exit(WIFI_FATAL_ERR);
	}

	(void) memmove(gbuf->wldp_buf, &bsstype, sizeof (wl_bss_type_t));
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_BSS_TYPE,
	    sizeof (wl_bss_type_t)));
}

static boolean_t
do_set_createibss(int fd, const char *arg)
{
	wl_create_ibss_t create_ibss;

	assert(arg != NULL);

	PRTDBG(("do_set_createibss(%d, \"%s\")\n", fd, arg));

	(void) memset(&create_ibss, 0x0, sizeof (create_ibss));

	if (strcasecmp(arg, "YES") == 0) {
		create_ibss = B_TRUE;
	} else if (strcasecmp(arg, "NO") == 0) {
		create_ibss = B_FALSE;
	} else {
		(void) fprintf(stderr, gettext("%s: "
		    "createibss: yes or no\n"), gExecName);
		exit(WIFI_FATAL_ERR);
	}

	(void) memmove(gbuf->wldp_buf, &create_ibss,
	    sizeof (wl_create_ibss_t));
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_CREATE_IBSS,
	    sizeof (wl_create_ibss_t)));
}

static boolean_t
do_set_channel(int fd, const char *arg)
{
	wl_phy_conf_t phy_conf;

	assert(arg != NULL);
	PRTDBG(("do_set_channel(%d, \"%s\")\n", fd, arg));

	(void) memset(&phy_conf, 0xff, sizeof (phy_conf));

	if (is_channel_valid(arg) == B_FALSE) {
		(void) fprintf(stderr, gettext("%s: channel No. "
		    "should be:\n"
		    "\t802.11a: 0-99\n"
		    "\t802.11b: 1-14\n"
		    "\t802.11g: 1-14\n"), gExecName);
		exit(WIFI_FATAL_ERR);
	}
	phy_conf.wl_phy_dsss_conf.wl_dsss_channel = atoi(arg);
	PRTDBG(("channel=%d\n", phy_conf.wl_phy_dsss_conf.wl_dsss_channel));

	(void) memmove(gbuf->wldp_buf, &phy_conf, sizeof (wl_phy_conf_t));
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_PHY_CONFIG,
	    sizeof (wl_phy_conf_t)));
}
/*
 * is_rates_support: Querying driver about supported rates.
 */
static boolean_t
is_rates_support(int fd, int num, uint8_t *rates)
{
	int rates_num = 0;
	int i = 0, j = 0;
	uint8_t value = 0;

	assert((rates != NULL)&&(num != 0));
	PRTDBG(("is_rates_support(%d, %d, 0x%x)\n", fd, num, rates));

	if (call_ioctl(fd, WLAN_GET_PARAM, WL_SUPPORTED_RATES, 0)
	    == B_TRUE) {
		rates_num = ((wl_rates_t *)(gbuf->wldp_buf))->wl_rates_num;

		for (i = 0; i < num; i++) {
			PRTDBG(("rates[%d] = %d\n", i, rates[i]));
			for (j = 0; j < rates_num; j++) {
				value = ((wl_rates_t *)gbuf->wldp_buf)
				    ->wl_rates_rates[j];
				PRTDBG(("supported rates[%d]=%d\n", j, value));
				if (value == rates[i]) {
					break;
				}
			}
			if (j == rates_num) {
				if (rates[i] == 11) {
					(void) fprintf(stderr,
					    gettext("%s: "
					    "rate 5.5M is not supported\n"),
					    gExecName);
				} else {
					(void) fprintf(stderr,
					    gettext("%s: "
					    "rate %dM is not supported\n"),
					    gExecName, rates[i]/2);
				}
				return (B_FALSE);
			}
		}
		return (B_TRUE);
	}
	return (B_FALSE);
}

/*
 *
 */
static uint8_t
rates_convert(const char *rates)
{
	int i;
	uint8_t ret;

	for (i = 0; i < WIFI_RATES_NUM; i++) {
		if (strcmp(rates, wifi_rates_s[i].rates_s) == 0) {
			ret = wifi_rates_s[i].rates_i;
			break;
		}
	}
	if (i == WIFI_RATES_NUM) {
		(void) fprintf(stderr, gettext("%s: "
		    "invalid rates '%s'\n"), gExecName, rates);
		exit(WIFI_FATAL_ERR);
	}
	return (ret);
}

/*
 * get_rates: convert string value arg into uint8_t array,
 * array length will be save into *len[i].
 * for example:
 * arg = "1,2,5.5,11"
 * then after call, rates[] = {2,4,11,22} will be returned.
 * and *len will equal to 4
 */
static uint8_t *
get_rates(const char *arg, uint32_t *len)
{
	int i = 1, j = 0;
	uint8_t *rates = NULL;
	char *pnext = NULL;
	char *token;
	char *pstart;
	char *pstart_bak;

	assert(arg != NULL);

	if (strlen(arg) == 0) {
		PRTDBG(("get_rates: empty rates string\n"));
		return (NULL);
	}
	PRTDBG(("get_rates(\"%s\", 0x%x)\n", arg, len));
	pstart = safe_strdup(arg);
	pstart_bak = pstart;
	while ((pnext = strchr(pstart, ',')) != NULL) {
		pstart = pnext + 1;
		i++;
	}
	*len = i;
	rates = safe_calloc(sizeof (uint8_t), i);

	pstart = pstart_bak;
	if ((token = strtok(pstart, ",")) != NULL) {
		PRTDBG(("rates[0]: %s\n", token));
		rates[0] = rates_convert(token);
		i = 1;
		while ((token = strtok(NULL, ",")) != NULL) {
			PRTDBG(("rates[%d]: %s\n", i, token));
			rates[i++] = rates_convert(token);
		}
	}
	free(pstart_bak);
	for (i = 0; i < *len; i++) {
		for (j = 0; j < i; j++)
			if (rates[j] == rates[i]) {
				(void) fprintf(stderr,
				    gettext("%s: rates duplicated\n"),
				    gExecName);
				free(rates);
				return (NULL);
			}
	}

	return (rates);
}

static boolean_t
do_set_rates(int fd, const char *arg)
{
	int i = 0;
	uint32_t num = 0;
	uint8_t *rates;

	assert(arg != NULL);

	PRTDBG(("do_set_rates(%d, \"%s\")\n", fd, arg));

	rates = get_rates(arg, &num);
	if ((rates == NULL) ||
	    is_rates_support(fd, num, rates) == B_FALSE) {
		exit(WIFI_FATAL_ERR);
	}

	((wl_rates_t *)(gbuf->wldp_buf))->wl_rates_num = num;
	for (i = 0; i < num; i++) {
		((wl_rates_t *)gbuf->wldp_buf)->wl_rates_rates[i]
		    = rates[i];
	}
	free(rates);
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_DESIRED_RATES,
	    offsetof(wl_rates_t, wl_rates_rates) +
	    num*sizeof (char)));
}

static boolean_t
do_set_powermode(int fd, const char *arg)
{
	wl_ps_mode_t ps_mode;

	assert(arg != NULL);

	PRTDBG(("do_set_powermode(%d, \"%s\")\n", fd, arg));

	(void) memset(&ps_mode, 0xff, sizeof (ps_mode));

	if ((strcasecmp(arg, "OFF") == 0) ||
	    (strcasecmp(arg, "MPS") == 0) ||
	    (strcasecmp(arg, "FAST") == 0)) {
		switch (arg[0]) {
		case 'O':
		case 'o':
			ps_mode.wl_ps_mode = WL_PM_AM;
			break;
		case 'M':
		case 'm':
			ps_mode.wl_ps_mode = WL_PM_MPS;
			break;
		case 'F':
		case 'f':
			ps_mode.wl_ps_mode = WL_PM_FAST;
			break;
		default:
			break;
		}
	} else {
		(void) fprintf(stderr,
		    gettext("%s: powermode: off mps or fast\n"), gExecName);
		exit(WIFI_FATAL_ERR);
	}

	(void) memmove(gbuf->wldp_buf, &ps_mode, sizeof (wl_ps_mode_t));
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_POWER_MODE,
	    sizeof (wl_ps_mode_t)));
}

static boolean_t
do_set_authmode(int fd, const char *arg)
{
	wl_authmode_t auth_mode;

	assert(arg != NULL);
	PRTDBG(("do_set_authmode(%d, \"%s\")\n", fd, arg));

	(void) memset(&auth_mode, 0xff, sizeof (auth_mode));
	/* Mark */
	if (strcasecmp(arg, "OPENSYSTEM") == 0) {
		auth_mode = WL_OPENSYSTEM;
	} else if (strcasecmp(arg, "SHARED_KEY") == 0) {
		auth_mode = WL_SHAREDKEY;
	} else {
		(void) fprintf(stderr,
		    gettext("%s: authmode: "
		    "opensystem or shared_key\n"), gExecName);
		exit(WIFI_FATAL_ERR);
	}

	(void) memmove(gbuf->wldp_buf, &auth_mode, sizeof (wl_authmode_t));
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_AUTH_MODE,
	    sizeof (wl_authmode_t)));
}

static boolean_t
do_set_encryption(int fd, const char *arg)
{
	wl_encryption_t encryption;

	assert(arg != NULL);
	PRTDBG(("do_set_encryption(%d, \"%s\")\n", fd, arg));

	(void) memset(&encryption, 0xff, sizeof (encryption));

	if (strcasecmp(arg, "NONE") == 0) {
		encryption = WL_NOENCRYPTION;
	} else if (strcasecmp(arg, "WEP") == 0) {
		encryption = WL_ENC_WEP;
	} else {
		(void) fprintf(stderr, gettext("%s: encryption: "
		    "none or wep\n"), gExecName);
		exit(WIFI_FATAL_ERR);
	}

	(void) memmove(gbuf->wldp_buf, &encryption, sizeof (wl_encryption_t));
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_ENCRYPTION,
	    sizeof (wl_encryption_t)));
}

static boolean_t
do_set_wepkeyid(int fd, const char *arg)
{
	wl_wep_key_id_t wep_key_id;

	assert(arg != NULL);
	PRTDBG(("do_set_wepkeyid(%d, \"%s\")\n", fd, arg));

	(void) memset(&wep_key_id, 0xff, sizeof (wep_key_id));
	if (is_wepkeyindex_valid(arg) == B_FALSE) {
		(void) fprintf(stderr, gettext("%s: wepkeyindex "
		    "should be an integer within the range 1-4\n"), gExecName);
		exit(WIFI_FATAL_ERR);
	}
	wep_key_id = atoi(arg) - 1;

	(void) memmove(gbuf->wldp_buf, &wep_key_id, sizeof (wl_wep_key_id_t));
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_WEP_KEY_ID,
	    sizeof (wl_wep_key_id_t)));
}

static boolean_t
do_set_radioon(int fd, const char *arg)
{
	wl_radio_t radio;

	assert(arg != NULL);
	PRTDBG(("do_set_radioon(%d, \"%s\")\n", fd, arg));

	(void) memset(&radio, 0xff, sizeof (radio));

	if (strcasecmp(arg, "ON") == 0) {
		radio = B_TRUE;
	} else if (strcasecmp(arg, "OFF") == 0) {
		radio = B_FALSE;
	} else {
		(void) fprintf(stderr,
		    gettext("%s: radio : on or off\n"), gExecName);
		exit(WIFI_FATAL_ERR);
	}

	(void) memmove(gbuf->wldp_buf, &radio, sizeof (wl_radio_t));
	return (call_ioctl(fd, WLAN_SET_PARAM, WL_RADIO, sizeof (wl_radio_t)));
}
/*
 * print_gbuf: After each ioctl system call, gbuf will contain result, gbuf
 * contents's format varies from each kind of ioctl system call.
 */
static void
print_gbuf(config_item_t index)
{
	int i = 0, j = 0;
	uint32_t ess_num;
	char **ess_argv;
	uint32_t rates_num;
	uint32_t subtype;
	wl_bss_type_t bsstype;
	wl_create_ibss_t createibss;
	wl_ps_mode_t *ps_mode;
	wl_authmode_t authmode;
	wl_encryption_t encryption;
	wl_wep_key_id_t wepkeyid;
	wl_rssi_t signal;
	wl_radio_t radioon;
	wl_ess_conf_t **p_ess_conf;
	wl_linkstatus_t linkstatus;
	char format[256], *ntstr;
	uint32_t maxessidlen = 0, nt = 0, cnt = 0;
	int len;
	uint8_t bssid[6];

	PRTDBG(("print_gbuf(%d)\n", index));
	assert(gbuf->wldp_length < MAX_BUF_LEN);

	switch (index) {
	case BSSID:
		(void) printf("\tbssid: ");
		(void) memset(bssid, 0, sizeof (bssid));
		if (memcmp((uint8_t *)gbuf->wldp_buf, bssid, sizeof (bssid))
		    == 0) {
			(void) printf("none\n");
			break;
		}
		(void) memset(bssid, 0xff, sizeof (bssid));
		if (memcmp((uint8_t *)gbuf->wldp_buf, bssid, sizeof (bssid))
		    == 0) {
			(void) printf("none\n");
			break;
		}
		for (i = 0; i < 5; i++)
			(void) printf("%02x:", ((uint8_t *)gbuf->wldp_buf)[i]);
		(void) printf("%02x\n", ((uint8_t *)gbuf->wldp_buf)[i]);
		break;
	case ESSID:
		(void) printf("\tessid: %s\n", ((wl_essid_t *)(gbuf->wldp_buf))
		    ->wl_essid_essid);
		break;
	case BSSTYPE:
		bsstype = *(wl_bss_type_t *)(gbuf->wldp_buf);
		switch (bsstype) {
		case WL_BSS_BSS:
			(void) printf("\tbsstype: bss(ap, infrastructure)\n");
			break;
		case WL_BSS_IBSS:
			(void) printf("\tbsstype: ibss(ad-hoc)\n");
			break;
		case WL_BSS_ANY:
			(void) printf("\tbsstype: auto\n");
			break;
		default:
			(void) fprintf(stderr,
			    gettext("%s: "
			    "invalid bsstype value\n"), gExecName);
		}
		break;
	case CREATEIBSS:
		createibss = *(wl_create_ibss_t *)(gbuf->wldp_buf);
		switch (createibss) {
		case B_TRUE:
			(void) printf("\tcreateibss: yes\n");
			break;
		case B_FALSE:
			(void) printf("\tcreateibss: no\n");
			break;
		default:
			(void) fprintf(stderr,
			    gettext("%s: "
			    "invalid createibss value\n"), gExecName);
		}
		break;
	case CHANNEL:
		subtype = ((wl_fhss_t *)(gbuf->wldp_buf))->wl_fhss_subtype;
		switch (subtype) {
		case WL_FHSS:
		case WL_DSSS:
		case WL_IRBASE:
		case WL_HRDS:
		case WL_ERP:
			(void) printf("\tchannel: %d\n", ((wl_fhss_t *)
			    (gbuf->wldp_buf))->wl_fhss_channel);
			break;
		case WL_OFDM:
			(void) printf("\tchannel: %d\n", ((wl_ofdm_t *)
			    (gbuf->wldp_buf))
			    ->wl_ofdm_frequency);
			break;
		default:
			(void) fprintf(stderr, gettext("%s: "
			    "invalid subtype\n"), gExecName);
			break;
		}
		break;
	case RATES:
		rates_num = ((wl_rates_t *)(gbuf->wldp_buf))->wl_rates_num;
		(void) printf("\trates: ");
		for (i = 0; i < rates_num; i++) {
			char rate;
			rate = ((wl_rates_t *)gbuf->wldp_buf)
			    ->wl_rates_rates[i];
			if (rate == WL_RATE_5_5M)
				(void) printf("5.5");
			else
				(void) printf("%d", (uint8_t)(rate / 2));

			if (i == (rates_num - 1))
				(void) printf("\n");
			else
				(void) printf(",");
		}
		break;
	case POWERMODE:
		ps_mode = (wl_ps_mode_t *)(gbuf->wldp_buf);
		switch (ps_mode->wl_ps_mode) {
		case WL_PM_AM:
			(void) printf("\tpowermode: off\n");
			break;
		case WL_PM_MPS:
			(void) printf("\tpowermode: mps\n");
			break;
		case WL_PM_FAST:
			(void) printf("\tpowermode: fast\n");
			break;
		default:
			(void) fprintf(stderr,
			    gettext("%s: "
			    "invalid powermode value\n"), gExecName);
			break;
		}
		break;
	case AUTHMODE:
		authmode = *(wl_authmode_t *)(gbuf->wldp_buf);
		switch (authmode) {
		case WL_OPENSYSTEM:
			(void) printf("\tauthmode: opensystem\n");
			break;
		case WL_SHAREDKEY:
			(void) printf("\tauthmode: shared_key\n");
			break;
		default:
			(void) fprintf(stderr,
			    gettext("%s: "
			    "invalid authmode value\n"), gExecName);
			break;
		}
		break;
	case ENCRYPTION:
		encryption = *(wl_encryption_t *)(gbuf->wldp_buf);
		switch (encryption) {
		case WL_NOENCRYPTION:
			(void) printf("\tencryption: none\n");
			break;
		case WL_ENC_WEP:
			(void) printf("\tencryption: wep\n");
			break;
		default:
			(void) fprintf(stderr,
			    gettext("%s: "
			    "invalid encryption value\n"), gExecName);
			break;
		}
		break;
	case WEPKEYID:
		wepkeyid = *(wl_wep_key_id_t *)(gbuf->wldp_buf);
		(void) printf("\twepkeyindex: %d\n", wepkeyid + 1);
		break;
	case SIGNAL:
		signal = *(wl_rssi_t *)(gbuf->wldp_buf);
		(void) printf("\tsignal: %d\n", signal);
		break;
	case RADIOON:
		radioon = *(wl_radio_t *)(gbuf->wldp_buf);
		switch (radioon) {
		case B_TRUE:
			(void) printf("\tradio: on\n");
			break;
		case B_FALSE:
			(void) printf("\tradio: off\n");
			break;
		default: /* Mark */
			(void) fprintf(stderr,
			    gettext("%s: "
			    "invalid radioon value\n"), gExecName);
		}
		break;
	case LINKSTATUS:
		linkstatus = *(wl_linkstatus_t *)(gbuf->wldp_buf);
		switch (linkstatus) {
		case WL_CONNECTED:
			(void) printf("\tlinkstatus: connected\n");
			break;
		case WL_NOTCONNECTED:
			(void) printf("\tlinkstatus: not connected\n");
			break;
		default: /* Mark */
			(void) fprintf(stderr,
			    gettext("%s: "
			    "invalid linkstatus value\n"), gExecName);
		}
		break;
	case WLANLIST:
		ess_num = ((wl_ess_list_t *)(gbuf->wldp_buf))->wl_ess_list_num;
		ess_argv = safe_calloc(sizeof (char *), ess_num);
		p_ess_conf = safe_calloc(sizeof (wl_ess_conf_t *), ess_num);
		for (i = 0; i < ess_num; i++) {
			p_ess_conf[i] = ((wl_ess_list_t *)gbuf->wldp_buf)
			    ->wl_ess_list_ess + i;
			maxessidlen = (maxessidlen >
			    strlen(p_ess_conf[i]
			    ->wl_ess_conf_essid.wl_essid_essid) ?
			    maxessidlen :
			    strlen(p_ess_conf[i]
			    ->wl_ess_conf_essid.wl_essid_essid));
		}
		/*
		 * construct the output format.
		 */
		if ((nt = (maxessidlen / 8 + 1)) > 4)
			nt = 4;
		len = snprintf(format, sizeof (format), gettext("essid"));
		ntstr = construct_format(nt);
		assert(ntstr != NULL);
		len += snprintf(format + len, sizeof (format) - len, "%s",
		    ntstr);
		len += snprintf(format + len, sizeof (format) - len,
		    gettext("bssid\t\t  type\t\tencryption\tsignallevel\n"));

		if ((len <= 0) || (len > sizeof (format) - 1)) {
			(void) printf("essid\t\t\t\tbssid\t\t  type\t\t"
			    "encryption\tsignallevel\n");
		} else {
			(void) printf("%s", format);
		}

		for (i = 0; i < ess_num; i++) {
			ess_argv[i] = safe_malloc(MAX_SCANBUF_LEN);
			safe_snprintf(ess_argv[i], MAX_SCANBUF_LEN,
			    "%s%c%02x:%02x:%02x:%02x:%02x:%02x%c%s",
			    p_ess_conf[i]->wl_ess_conf_essid.wl_essid_essid,
			    ',',
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[0]),
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[1]),
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[2]),
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[3]),
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[4]),
			    (uint8_t)(p_ess_conf[i]->wl_ess_conf_bssid[5]), ',',
			    (p_ess_conf[i]->wl_ess_conf_wepenabled ==
			    B_TRUE ? "wep":"none"));
			len = strlen(p_ess_conf[i]->wl_ess_conf_essid.
			    wl_essid_essid);
			cnt = nt - (min(len /8 + 1, 4) - 1);
			ntstr = construct_format(cnt);
			assert(ntstr != NULL);
			(void) printf("%s%s", p_ess_conf[i]->wl_ess_conf_essid.
			    wl_essid_essid, ntstr);
			free(ntstr);
			for (j = 0; j < 5; j++) {
				(void) printf("%02x:", (uint8_t)(p_ess_conf[i]
				    ->wl_ess_conf_bssid[j]));
			}
			(void) printf("%02x ", (uint8_t)(p_ess_conf[i]
			    ->wl_ess_conf_bssid[j]));

			if (p_ess_conf[i]->wl_ess_conf_bsstype ==
			    WL_BSS_BSS)
				(void) printf("access point");
			else
				(void) printf("ad-hoc");
			if (p_ess_conf[i]->wl_ess_conf_wepenabled ==
			    WL_ENC_WEP)
				(void) printf("\twep\t");
			else
				(void) printf("\tnone\t");
			(void) printf("\t%d\n", p_ess_conf[i]->wl_ess_conf_sl);
		}
		add_to_history(gp_config_file, ess_num, ess_argv);
		free(p_ess_conf);
		for (i = 0; i < ess_num; i++) {
			free(ess_argv[i]);
		}
		free(ess_argv);
		break;
	default:
		(void) fprintf(stderr, gettext("%s: "
		    "invalid parameter type\n"), gExecName);
		break;
	}
}
/*
 * do_get_xxx: will send ioctl to driver, then the driver will fill gbuf
 * with related value. gbuf has a format of wldp_t structure.
 */
static boolean_t
do_get_bssid(int fd)
{
	PRTDBG(("do_get_bssid(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_BSSID, 0));
}

static boolean_t
do_get_essid(int fd)
{
	PRTDBG(("do_get_essid(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_ESSID, 0));
}

static boolean_t
do_get_bsstype(int fd)
{
	PRTDBG(("do_get_bsstype(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_BSS_TYPE, 0));
}

static boolean_t
do_get_createibss(int fd)
{
	PRTDBG(("do_get_createibss(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_CREATE_IBSS, 0));
}

static boolean_t
do_get_channel(int fd)
{
	PRTDBG(("do_get_channel(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_PHY_CONFIG, 0));
}

static boolean_t
do_get_wlanlist(int fd)
{
	PRTDBG(("do_get_wlanlist(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_ESS_LIST, 0));
}

static boolean_t
do_get_linkstatus(int fd)
{
	PRTDBG(("do_get_linkstauts(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_LINKSTATUS, 0));
}

static boolean_t
do_get_rates(int fd)
{
	PRTDBG(("do_get_rates(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_DESIRED_RATES, 0));
}

static boolean_t
do_get_powermode(int fd)
{
	PRTDBG(("do_get_powermode(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_POWER_MODE, 0));
}

static boolean_t
do_get_authmode(int fd)
{
	PRTDBG(("do_get_authmode(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_AUTH_MODE, 0));
}

static boolean_t
do_get_encryption(int fd)
{
	PRTDBG(("do_get_encryption(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_ENCRYPTION, 0));
}

static boolean_t
do_get_wepkeyid(int fd)
{
	PRTDBG(("do_get_wepkeyid(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_WEP_KEY_ID, 0));
}
static boolean_t
do_get_signal(int fd)
{
	PRTDBG(("do_get_signal(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_RSSI, 0));
}

static boolean_t
do_get_radioon(int fd)
{
	PRTDBG(("do_get_radioon(%d)\n", fd));
	return (call_ioctl(fd, WLAN_GET_PARAM, WL_RADIO, 0));
}

/*
 * param has two kinds of forms:
 * 'wepkeyn=*****' (when equalflag == B_TRUE),
 * 'wepkeyn' (when equalflag == B_FALSE)
 */
static boolean_t
param_is_wepkey(char *param, boolean_t equalflag)
{
	if ((equalflag == B_FALSE) &&
	    (strcmp(param, "wepkey1") == 0) ||
	    (strcmp(param, "wepkey2") == 0) ||
	    (strcmp(param, "wepkey3") == 0) ||
	    (strcmp(param, "wepkey4") == 0))
		return (B_TRUE);
	else if ((equalflag == B_TRUE) &&
	    (strncmp(param, "wepkey1=", strlen("wepkey1="))) == 0 ||
	    (strncmp(param, "wepkey2=", strlen("wepkey2="))) == 0 ||
	    (strncmp(param, "wepkey3=", strlen("wepkey3="))) == 0 ||
	    (strncmp(param, "wepkey4=", strlen("wepkey4="))) == 0)
		return (B_TRUE);
	else
		return (B_FALSE);
}

/*
 * update/add items in the profile
 */
static boolean_t
items_in_profile(aelist_t *cplist, aelist_t *wplist, int argc, char **argv)
{
	int i = 0, j = 0;
	char *param;
	char *pequal;
	const char *wepkey;

	for (i = 0; i < argc; i++) {
		if (param_is_wepkey(argv[i], B_TRUE) == B_TRUE) {
			wepkey = get_value(argv[i]);
			if (value_is_valid(WEPKEY, wepkey) == B_FALSE) {
				(void) fprintf(stderr, gettext("%s: "
				    "invalid value '%s' for parameter "
				    "'wepkey'\n"), gExecName, wepkey);
				return (B_FALSE);
			}
			update_aelist(wplist, argv[i]);
			continue;
		}
		param = safe_strdup(argv[i]);
		pequal = strchr(param, '=');
		if (pequal == NULL) {
			(void) fprintf(stderr, gettext("%s: "
			    "invalid argument '%s', use "
			    "parameter=value'\n"),
			    gExecName, argv[i]);
			free(param);
			return (B_FALSE);
		}

		*pequal++ = '\0';
		for (j = 0; j < N_GS_FUNC; j++) {
			if (strcmp(param, do_gs_func[j].cmd) == 0) {
				break;
			}
		}
		if (j == N_GS_FUNC) {
			(void) fprintf(stderr, gettext("%s: "
			    "unrecognized parameter '%s'\n"),
			    gExecName, param);
			free(param);
			return (B_FALSE);
		}
		if (value_is_valid(do_gs_func[j].index, pequal) ==
		    B_FALSE) {
			(void) fprintf(stderr, gettext("%s: "
			    "invalid value '%s' for parameter '%s'\n"),
			    gExecName, pequal, param);
			return (B_FALSE);
		}
		free(param);
		update_aelist(cplist, argv[i]);
	}
	return (B_TRUE);
}

/*
 * do_createprofile: Called when create a profile off-line.
 */
/*ARGSUSED*/
static boolean_t
do_createprofile(int fd, int argc, char **argv)
{
	int i = 0;
	char *pbuf = NULL;
	char *pfbuf = NULL;
	const char *profilename;
	aelist_t *plist_config = NULL, *plist_wepkey = NULL;

	PRTDBG(("do_createprofile(%d, 0x%x)\n", argc, argv));
	if (argc <= 0) {
		do_print_usage();
		exit(WIFI_IMPROPER_USE);
	}
	/*
	 * When creating a profile, if the profile name is not specified,
	 * the essid is selected as the profile name. the paramters are
	 * saved into the section.
	 */
	if (strchr(argv[0], '=') == NULL) {
		pfbuf = safe_strdup(argv[0]);
		argc--;
		argv++;
	}
	for (i = 0; i < argc; i++) {
		if (strncmp(argv[i], "essid=", strlen("essid=")) == 0) {
			break;
		}
	}
	if (i == argc) {
		(void) fprintf(stderr,
		    gettext("%s: "
		    "essid required when creating profile\n"),
		    gExecName);
		goto exit0;
	}
	profilename = (pfbuf ? pfbuf : get_value(argv[i]));
	if (strlen(profilename) == 0) {
		(void) fprintf(stderr,
		    gettext("%s: "
		    "non-empty essid required\n"),
		    gExecName);
		goto exit0;
	}
	/*
	 * 'all', '{preference}', '{history}', '{active_profile}'
	 * and any string with '[' as start and ']' as end should
	 * not be a profile name
	 */
	if ((strcasecmp(profilename, "all") == 0) ||
	    (strcmp(profilename, WIFI_HISTORY) == 0) ||
	    (strcmp(profilename, WIFI_PREFER) == 0) ||
	    (strcmp(profilename, WIFI_ACTIVEP) == 0) ||
	    ((profilename[0] == '[') &&
	    (profilename[strlen(profilename) - 1] == ']'))) {
		(void) fprintf(stderr, gettext("%s: "
		    "'%s' is an invalid profile name\n"),
		    gExecName, profilename);
		goto exit0;
	}
	pbuf = append_pa(profilename);

	PRTDBG(("do_createprofile: profile_name = %s\n", pbuf));
	if ((find_section(gp_config_file, pbuf) != NULL) ||
	    find_section(gp_wepkey_file, pbuf) != NULL) {
		(void) fprintf(stderr,
		    gettext("%s: "
		    "profile '%s' already exists\n"),
		    gExecName, profilename);
		goto exit1;
	}
	/*
	 * Save each parameters in the profile.
	 */
	plist_config = new_ael(PROFILE);
	new_section(gp_config_file, plist_config, pbuf);
	plist_wepkey = new_ael(PROFILE);
	new_section(gp_wepkey_file, plist_wepkey, pbuf);
	free(pfbuf);
	free(pbuf);
	return (items_in_profile(plist_config, plist_wepkey,
	    argc, argv));
exit1:
	free(pbuf);
exit0:
	free(pfbuf);
	return (B_FALSE);
}

/*ARGSUSED*/
static boolean_t
do_setprofparam(int fd, int argc, char **argv)
{
	char *pbuf = NULL;
	section_t *psection_config = NULL, *psection_wep = NULL;
	aelist_t *plist_config = NULL, *plist_wepkey = NULL;

	PRTDBG(("do_setprofparam(%d, 0x%x)\n", argc, argv));
	if (argc < 1) {
		do_print_usage();
		exit(WIFI_IMPROPER_USE);
	}
	pbuf = append_pa(argv[0]);

	psection_config = find_section(gp_config_file, pbuf);
	psection_wep = find_section(gp_wepkey_file, pbuf);
	if ((psection_config == NULL) || (psection_wep == NULL)) {
		(void) fprintf(stderr, gettext("%s: "
		    "profile '%s' doesn't exist\n"),
		    gExecName, argv[0]);
		free(pbuf);
		return (B_FALSE);
	}
	free(pbuf);
	/*
	 * modify each parameters in the profile.
	 */
	plist_config = psection_config->list;
	plist_wepkey = psection_wep->list;
	argc--;
	argv++;
	return (items_in_profile(plist_config, plist_wepkey,
	    argc, argv));
}

/*ARGSUSED*/
static boolean_t
do_getprofparam(int fd, int argc, char **argv)
{
	int i = 0, j = 0;
	int flag;
	boolean_t ret = B_TRUE;
	section_t *p_section = NULL;
	aelist_t *plist = NULL;
	ae_t *pae = NULL;
	char *pbuf = NULL;

	PRTDBG(("do_getprofparam(%d, 0x%x)\n", argc, argv));
	if (argc < 1) {
		do_print_usage();
		exit(WIFI_IMPROPER_USE);
	}
	pbuf = append_pa(argv[0]);
	p_section = find_section(gp_config_file, pbuf);
	if (p_section == NULL) {
		(void) fprintf(stderr, gettext("%s: "
		    "profile '%s' doesn't exist\n"),
		    gExecName, argv[0]);
		ret = B_FALSE;
		goto exit0;
	}
	argc--;
	argv++;

	plist = p_section->list;
	assert(plist != NULL);
	/*
	 * If no specific parameter typed, we print out all parameters
	 */
	if (argc == 0) {
		pae = plist->ael_head;
		while (pae != NULL) {
			if (pae->ae_arg != NULL) {
				(void) printf("\t%s\n", pae->ae_arg);
			}
			pae = pae->ae_next;
		}
		print_wepkey_info(p_section->section_id, NULL);
		ret = B_TRUE;
		goto exit0;
	}

	/*
	 * Match function with do_gs_func[] table, and print its result
	 */
	for (i = 0; i < argc; i++) {
		flag = 0;
		for (j = 0; j < N_GS_FUNC; j++) {
			if (strcmp(argv[i], do_gs_func[j].cmd) == 0) {
				break;
			}
			if (param_is_wepkey(argv[i], B_FALSE) == B_TRUE) {
				j = WEPKEY;
				print_wepkey_info(p_section->section_id,
				    argv[i]);
				flag++;
				break;
			}
		}
		if (j == N_GS_FUNC) {
			(void) fprintf(stderr,
			    gettext("wificonifg: unrecognized parameter: "
			    "%s\n"), argv[i]);
			ret = B_FALSE;
			goto exit0;
		}

		pae = plist->ael_head;
		while ((pae != NULL) && (!flag)) {
			if ((pae->ae_arg != NULL) &&
			    (strncmp(pae->ae_arg, argv[i],
			    strlen(argv[i])) == 0)) {
				(void) printf("\t%s\n", pae->ae_arg);
				flag++;
			}
			pae = pae->ae_next;
		}
		if (!flag) {
			(void) fprintf(stderr, gettext("%s: "
			    "parameter '%s' has not been set in profile %s\n"),
			    gExecName, argv[i], pbuf);
			ret = B_FALSE;
			goto exit0;
		}
	}
exit0:
	free(pbuf);
	return (ret);
}

/*
 * Verify whether the value in the parameter=value pair is valid or not.
 * For the channel, since we donot know what kind of wifi card(a,b,or g)
 * is in the system, so we just leave to verify the validity of the value
 * when the value is set to the card.
 * The same goes for the rates.
 */
static boolean_t
value_is_valid(config_item_t item, const char *value)
{
	uint32_t num = 0;
	uint8_t *rates;
	boolean_t ret;

	assert(value != NULL);
	switch (item) {
	case ESSID:
		if (strlen(value) > 32)
			ret = B_FALSE;
		else
			ret = B_TRUE;
		break;
	case BSSTYPE:
		if ((strcasecmp(value, "bss") == 0) ||
		    (strcasecmp(value, "ap") == 0) ||
		    (strcasecmp(value, "infrastructure") == 0) ||
		    (strcasecmp(value, "ibss") == 0) ||
		    (strcasecmp(value, "ad-hoc") == 0) ||
		    (strcasecmp(value, "auto") == 0))
			ret = B_TRUE;
		else
			ret = B_FALSE;
		break;
	case CREATEIBSS:
		if ((strcasecmp(value, "yes") == 0) ||
		    (strcasecmp(value, "no") == 0))
			ret = B_TRUE;
		else
			ret = B_FALSE;
		break;
	case AUTHMODE:
		if ((strcasecmp(value, "opensystem") == 0) ||
		    (strcasecmp(value, "shared_key") == 0))
			ret = B_TRUE;
		else
			ret = B_FALSE;
		break;
	case POWERMODE:
		if ((strcasecmp(value, "off") == 0) ||
		    (strcasecmp(value, "mps") == 0) ||
		    (strcasecmp(value, "fast") == 0))
			ret = B_TRUE;
		else
			ret = B_FALSE;
		break;
	case ENCRYPTION:
		if ((strcasecmp(value, "wep") == 0) ||
		    (strcasecmp(value, "none") == 0))
			ret = B_TRUE;
		else
			ret = B_FALSE;
		break;
	case RADIOON:
		if ((strcasecmp(value, "on") == 0) ||
		    (strcasecmp(value, "off") == 0))
			ret = B_TRUE;
		else
			ret = B_FALSE;
		break;
	case WEPKEYID:
		ret = is_wepkeyindex_valid(value);
		break;
	case WEPKEY:
		ret = is_wepkey_valid(value, strlen(value));
		break;
	case CHANNEL:
		ret = is_channel_valid(value);
		break;
	case RATES:
		rates = get_rates(value, &num);
		if (rates == NULL) {
			ret = B_FALSE;
		} else {
			free(rates);
			ret = B_TRUE;
		}
		break;
	default:
		ret = B_FALSE;
		break;
	}

	return (ret);
}

/*
 * do_set: Called when set a parameter, the format should be
 * parameter=value.
 */
static boolean_t
do_set(int fd, int argc, char **argv)
{
	int i = 0, j = 0;
	char *param;
	char *pequal;
	char *value;
	boolean_t ret;

	PRTDBG(("do_set(%d, 0x%x)\n", argc, argv));
	assert(fd > 0);
	if (argc <= 0) {
		(void) do_print_support_params(fd);
		ret = B_FALSE;
		goto exit0;
	}
	/*
	 * Set each parameters, if one failed, others behind it will
	 * not be set
	 */
	for (i = 0; i < argc; i++) {
		/*
		 * Separate param and its value, if the user types "param=",
		 * then value will be set to "";if the user types "param",
		 * it is an error.
		 */
		param = safe_strdup(argv[i]);
		pequal = strchr(param, '=');
		value = NULL;
		if (pequal != NULL) {
			*pequal = '\0';
			value = pequal + 1;
		} else {
			(void) fprintf(stderr,
			    gettext("%s: invalid setparam argument "
			    "'%s', use 'parameter=value'\n"),
			    gExecName, argv[i]);
			free(param);
			ret = B_FALSE;
			goto exit0;
		}
		PRTDBG(("do_set: param = \"%s\", value = \"%s\"\n",
		    param, value));
		for (j = 0; j < N_GS_FUNC; j++) {
			/*
			 * Match each parameters with do_gs_func table,
			 */
			if (strcmp(param, do_gs_func[j].cmd) == 0)
				break;
			if (param_is_wepkey(param, B_FALSE) == B_TRUE) {
				value = argv[i];
				j = WEPKEY;
				break;
			}
		}
		if (j == N_GS_FUNC) {
			(void) fprintf(stderr,
			    gettext("%s: unrecognized parameter: "
			    "%s\n"), gExecName, param);
			free(param);
			ret  = B_FALSE;
			goto exit0;
		}

		if (do_gs_func[j].p_do_set_func == NULL) {
			(void) fprintf(stderr,
			    gettext("%s: parameter '%s' is read-only\n"),
			    gExecName, do_gs_func[j].cmd);
			free(param);
			ret = B_FALSE;
			goto exit0;
		}
		if (do_gs_func[j].p_do_set_func(fd, value)
			    == B_TRUE) {
			ret = B_TRUE;
		} else {
			if (gbuf->wldp_result != WL_SUCCESS) {
				(void) fprintf(stderr,
				    gettext("%s: "
				    "failed to set '%s' for "),
				    gExecName, param);
				print_error(gbuf->wldp_result);
			}
			free(param);
			ret = B_FALSE;
			goto exit0;
		}
		free(param);
	}
exit0:
	return (ret);
}

static boolean_t
do_get(int fd, int argc, char **argv)
{
	int i = 0, j = 0, n = 0;
	boolean_t ret = B_TRUE;

	PRTDBG(("do_get(%d, 0x%x)\n", argc, argv));
	assert(fd > 0);
	/*
	 * If no specific parameter typed, we print out all parameters
	 */
	if (argc <= 0) {
		for (i = 0; i < N_GS_FUNC; i++) {
			if ((do_gs_func[i].p_do_get_func != NULL) &&
			    (do_gs_func[i].p_do_get_func(fd)
			    == B_TRUE)) {
				print_gbuf(do_gs_func[i].index);
				n++;
			}
		}
		ret = n ? B_TRUE:B_FALSE;
		goto exit0;
	}
	/*
	 * Match function with do_gs_func[] table, and print its result
	 */
	for (i = 0; i < argc; i++) {
		for (j = 0; j < N_GS_FUNC; j++) {
			if (strcmp(argv[i], do_gs_func[j].cmd) == 0) {
				break;
			}
			if (param_is_wepkey(argv[i], B_FALSE) == B_TRUE) {
				j = WEPKEY;
				break;
			}
		}
		if (j == N_GS_FUNC) {
			(void) fprintf(stderr,
			    gettext("wificonifg: unrecognized parameter: "
			    "%s\n"), argv[i]);
			ret = B_FALSE;
			goto exit0;
		}
		if (do_gs_func[j].p_do_get_func == NULL) {
			(void) fprintf(stderr,
			    gettext("%s: parameter '%s' is write-only\n"),
			    gExecName, do_gs_func[j].cmd);
			ret = B_FALSE;
			goto exit0;
		}
		if (do_gs_func[j].p_do_get_func(fd) == B_TRUE) {
			print_gbuf(do_gs_func[j].index);
			ret = B_TRUE;
		} else {
			(void) fprintf(stderr,
			    gettext("%s: "
			    "failed to read parameter '%s' : "),
			    gExecName, argv[i]);
			print_error(gbuf->wldp_result);
			ret = B_FALSE;
		}
	}
exit0:
	return (ret);
}

/*
 * Only one wificonfig is running at one time.
 * The following wificonfig which tries to be run will return error,
 * and the pid of the process will own the filelock will be printed out.
 */
static pid_t
enter_wifi_lock(int *fd)
{
	int fd0 = -1;
	struct flock lock;

	fd0 = open(WIFI_LOCKF, O_CREAT|O_WRONLY, 0600);
	if (fd0 < 0) {
		(void) fprintf(stderr, gettext("%s: failed to open lockfile"
		    " '"WIFI_LOCKF"': %s\n"), gExecName, strerror(errno));
		exit(WIFI_FATAL_ERR);
	}

	*fd = fd0;
	lock.l_type = F_WRLCK;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;

	if ((fcntl(fd0, F_SETLK, &lock) == -1) &&
	    (errno == EAGAIN || errno == EDEADLK)) {
		if (fcntl(fd0, F_GETLK, &lock) == -1) {
			(void) fprintf(stderr,
			    gettext("%s: enter_filelock"));
			exit(WIFI_FATAL_ERR);
		}
		(void) fprintf(stderr, gettext("%s:"
		    "enter_filelock:filelock is owned "
		    "by 'process %d'\n"), gExecName, lock.l_pid);
		return (lock.l_pid);
	}

	return (getpid());
}

static void
exit_wifi_lock(int fd)
{
	struct flock lock;

	lock.l_type = F_UNLCK;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;
	if (fcntl(fd, F_SETLK, &lock) == -1) {
		(void) fprintf(stderr, gettext("%s: failed to"
		    " exit_filelock: %s\n"),
		    gExecName, strerror(errno));
	}
	(void) close(fd);
}

int
main(int argc, char **argv)
{
	int i, ret;
	int fddev = -1;
	int c, iflag = 0, rflag = 0, fileonly = 0, readonly = 0;
	int fd;
	char *iname = NULL;
	char *path = NULL;
	extern char *optarg;
	extern int optind;
	char interface[LIFNAMSIZ];
	char file_wifi[MAX_CONFIG_FILE_LENGTH];
	char file_wifiwepkey[MAX_CONFIG_FILE_LENGTH];
	priv_set_t *ppriv;
	wifi_auth_t autht;

	PRTDBG(("main(%d, 0x%x)\n", argc, argv));
	PRTDBG(("uid=%d\n", getuid()));
	PRTDBG(("euid=%d\n", geteuid()));

#ifdef DEBUG
	if (wifi_debug == 1) { /* for debuf purpose only */
		(void) printf("Press RETURN to continue...\n");
		(void) getchar();
	}
#endif
	ret = WIFI_EXIT_DEF;

	(void) setlocale(LC_ALL, "");
	(void) textdomain(TEXT_DOMAIN);

	gExecName = argv[0];

	gbuf = safe_malloc(MAX_BUF_LEN);

	if ((ppriv = priv_str_to_set("basic", ",", NULL)) == NULL) {
		PRTDBG(("main: priviledge init error\n"));
		(void) fprintf(stderr, gettext("%s: "
		    "set priviledge to 'basic' error\n"),
		    gExecName);
		ret = WIFI_FATAL_ERR;
		goto exit0;
	}
	(void) priv_addset(ppriv, PRIV_NET_RAWACCESS);
	(void) priv_addset(ppriv, PRIV_SYS_NET_CONFIG);
	if (setppriv(PRIV_SET, PRIV_PERMITTED, ppriv) == -1) {
		(void) fprintf(stderr, gettext("%s: "
		    "set permitted priviledge: %s\n"),
		    gExecName, strerror(errno));
		ret = WIFI_FATAL_ERR;
		goto exit0;
	}
	if (setppriv(PRIV_SET, PRIV_LIMIT, ppriv) == -1) {
		(void) fprintf(stderr, gettext("%s: "
		    "set limit priviledge: %s\n"),
		    gExecName, strerror(errno));
		ret = WIFI_FATAL_ERR;
		goto exit0;
	}
	if (setppriv(PRIV_SET, PRIV_INHERITABLE, ppriv) == -1) {
		(void) fprintf(stderr, gettext("%s: "
		    "set inherit priviledge: %s\n"),
		    gExecName, strerror(errno));
		ret = WIFI_FATAL_ERR;
		goto exit0;
	}
	if (setppriv(PRIV_SET, PRIV_EFFECTIVE, ppriv) == -1) {
		(void) fprintf(stderr, gettext("%s: "
		    "set effective priviledge: %s\n"),
		    gExecName, strerror(errno));
		ret = WIFI_FATAL_ERR;
		goto exit0;
	}
	priv_freeset(ppriv);

	for (i = 0; i < argc; i++) {
		PRTDBG(("%d\t\t\"%s\"\n", i, argv[i]));
	}

	while ((c = getopt(argc, argv, "i:R:")) != EOF) {
		switch (c) {
		case 'i':
			if (iflag) {
				do_print_usage();
				ret = WIFI_IMPROPER_USE;
				goto exit0;
			}
			iflag = 1;
			iname = optarg;
			break;
		case 'R':
			if (rflag) {
				do_print_usage();
				ret = WIFI_IMPROPER_USE;
				goto exit0;
			}
			rflag = 1;
			path = optarg;
			break;
		case '?':
		default:
			do_print_usage();
			ret = WIFI_IMPROPER_USE;
			goto exit0;
		}
	}
	argc -= optind;
	argv +=	optind;

	if (argc <= 0) {
		if (iname) {
			if ((fddev = open_dev(iname)) == -1) {
				ret = WIFI_FATAL_ERR;
				goto exit0;
			}
			if (do_print_support_params(fddev) ==
			    B_TRUE)
				ret = WIFI_EXIT_DEF;
			else
				ret = WIFI_FATAL_ERR;
			goto exit1;
		} else {
			do_print_usage();
			ret = WIFI_IMPROPER_USE;
			goto exit0;
		}
	}

	for (i = 0; i < N_FUNC; i++) {
		if (strcmp(argv[0], do_func[i].cmd) == 0) {
			autht = ((strcmp(argv[0], "setwepkey") == 0) ||
			    (strcmp(argv[0], "setprofwepkey") == 0)) ?
			    AUTH_WEP:AUTH_OTHER;
			if (do_func[i].b_auth &&
			    !check_authority(autht)) {
				ret = WIFI_FATAL_ERR;
				goto exit0;
			}
			if (do_func[i].b_fileonly)
				fileonly++;
			if (do_func[i].b_readonly)
				readonly++;
			break;
		}
	}
	if (i == N_FUNC) {
		(void) fprintf(stderr, gettext("%s: unrecognized "
		    "subcommand: %s\n"), gExecName, argv[0]);
		do_print_usage();
		ret = WIFI_IMPROPER_USE;
		goto exit0;
	}
	if ((fileonly) && (iname)) {
		do_print_usage();
		ret = WIFI_IMPROPER_USE;
		goto exit0;
	}
	if ((!fileonly) && (!iname)) {
		if (search_interface(interface) != B_TRUE) {
			(void) fprintf(stderr, gettext("%s: "
			    "failed to find the default wifi interface;"
			    " -i option should be used to specify the "
			    "wifi interface\n"), gExecName);
			ret = WIFI_FATAL_ERR;
			goto exit0;
		}
		iname = interface;
	}
	if (iname) {
		if ((fddev = open_dev(iname)) == -1) {
			ret = WIFI_FATAL_ERR;
			goto exit0;
		}
	}
	if (rflag) {
		safe_snprintf(file_wifi, sizeof (file_wifi),
		    "%s%s", path, p_file_wifi);
		safe_snprintf(file_wifiwepkey, sizeof (file_wifiwepkey),
		    "%s%s", path, p_file_wifiwepkey);
	} else {
		safe_snprintf(file_wifi, sizeof (file_wifi),
		    "%s", p_file_wifi);
		safe_snprintf(file_wifiwepkey, sizeof (file_wifiwepkey),
		    "%s", p_file_wifiwepkey);
	}
	/*
	 * There is an occasion when more than one wificonfig processes
	 * which attempt to write the <wifi> and <wifiwepkey> files are
	 * running. We must be able to avoid this.
	 * We use file lock here to implement this.
	 */
	if ((!readonly) && (enter_wifi_lock(&fd) != getpid())) {
		ret = WIFI_FATAL_ERR;
		goto exit1;
	}
	gp_config_file = parse_file(file_wifi);
	if (gp_config_file == NULL) {
		ret = WIFI_FATAL_ERR;
		goto exit2;
	}

	gp_wepkey_file = parse_file(file_wifiwepkey);
	if (gp_wepkey_file == NULL) {
		destroy_config(gp_config_file);
		ret = WIFI_FATAL_ERR;
		goto exit2;
	}
	if (do_func[i].p_do_func(fddev, argc-1, argv+1)
	    == B_TRUE) {
		/*
		 * can not write file when startconfing
		 * during boot
		 */
		if (do_func[i].b_readonly)
			ret = WIFI_EXIT_DEF;
		else if ((fprint_config_file(gp_config_file,
		    file_wifi) != B_TRUE) ||
		    (fprint_config_file(gp_wepkey_file,
		    file_wifiwepkey) != B_TRUE))
			ret = WIFI_FATAL_ERR;
		else
			ret = WIFI_EXIT_DEF;
	} else {
		PRTDBG(("Command %s failed\n", argv[0]));
		ret = WIFI_FATAL_ERR;
	}
	destroy_config(gp_wepkey_file);
	destroy_config(gp_config_file);
exit2:
	if (!readonly)
		exit_wifi_lock(fd);
exit1:
	if (iname)
		(void) close(fddev);
exit0:
	free(gbuf);
	return (ret);
}

#ifdef DEBUG
static void
wifi_dbgprintf(char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	(void) vfprintf(stdout, fmt, ap);
	va_end(ap);
}
#endif