static int hostapd_global_init(struct hapd_interfaces *interfaces)
{
hostapd_logger_register_cb(hostapd_logger_cb);
if (eap_server_register_methods()) {
wpa_printf(MSG_ERROR, "Failed to register EAP methods");
return -1;
}
if (eloop_init()) {
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
return -1;
}
#ifndef CONFIG_NATIVE_WINDOWS
eloop_register_signal(SIGHUP, handle_reload, interfaces);
eloop_register_signal(SIGUSR1, handle_dump_state, interfaces);
#endif /* CONFIG_NATIVE_WINDOWS */
eloop_register_signal_terminate(handle_term, interfaces);
#ifndef CONFIG_NATIVE_WINDOWS
openlog("hostapd", 0, LOG_DAEMON);
#endif /* CONFIG_NATIVE_WINDOWS */
return 0;
}
int eloop_register_signal_terminate(eloop_signal_handler handler,
void *user_data) {
int ret = eloop_register_signal(SIGINT, handler, user_data);
if (ret == 0)
ret = eloop_register_signal(SIGTERM, handler, user_data);
return ret;
}
int eloop_register_signal_terminate(void (*handler)(int sig, void *eloop_ctx,
void *signal_ctx),
void *user_data)
{
#if 0
/* TODO: for example */
int ret = eloop_register_signal(SIGINT, handler, user_data);
if (ret == 0)
ret = eloop_register_signal(SIGTERM, handler, user_data);
return ret;
#endif
return 0;
}
int eloop_register_signal_reconfig(eloop_signal_handler handler,
void *user_data) {
#ifdef CONFIG_NATIVE_WINDOWS
return 0;
#else /* CONFIG_NATIVE_WINDOWS */
return eloop_register_signal(SIGHUP, handler, user_data);
#endif /* CONFIG_NATIVE_WINDOWS */
}
static int hostapd_global_init(struct hapd_interfaces *interfaces,
const char *entropy_file)
{
int i;
os_memset(&global, 0, sizeof(global));
hostapd_logger_register_cb(hostapd_logger_cb);
if (eap_server_register_methods()) {
wpa_printf(MSG_ERROR, "Failed to register EAP methods");
return -1;
}
if (eloop_init()) {
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
return -1;
}
random_init(entropy_file);
#ifndef CONFIG_NATIVE_WINDOWS
eloop_register_signal(SIGHUP, handle_reload, interfaces);
eloop_register_signal(SIGUSR1, handle_dump_state, interfaces);
#endif /* CONFIG_NATIVE_WINDOWS */
eloop_register_signal_terminate(handle_term, interfaces);
/*Timeout event is triggered after 5 seconds of start of hostapd. The parameters are pulled after the event is triggered in the handler*/
// eloop_register_timeout(5, 0, get_params_handler, &ctx, NULL);
#ifndef CONFIG_NATIVE_WINDOWS
openlog("hostapd", 0, LOG_DAEMON);
#endif /* CONFIG_NATIVE_WINDOWS */
for (i = 0; wpa_drivers[i]; i++)
global.drv_count++;
if (global.drv_count == 0) {
wpa_printf(MSG_ERROR, "No drivers enabled");
return -1;
}
global.drv_priv = os_calloc(global.drv_count, sizeof(void *));
if (global.drv_priv == NULL)
return -1;
return 0;
}
int eloop_register_signal_reassociate(eloop_signal_handler handler,
void *user_data)
{
#ifdef CONFIG_NATIVE_WINDOWS
return 0;
#else /* CONFIG_NATIVE_WINDOWS */
return eloop_register_signal(SIGUSR2, handler, user_data);
#endif /* CONFIG_NATIVE_WINDOWS */
}
static int hostapd_global_init(struct hapd_interfaces *interfaces,
const char *entropy_file)
{
int i;
//重只global变量
os_memset(&global, 0, sizeof(global));
hostapd_logger_register_cb(hostapd_logger_cb);
//注册eap server的加密方法
if (eap_server_register_methods()) {
wpa_printf(MSG_ERROR, "Failed to register EAP methods");
return -1;
}
if (eloop_init()) {
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
return -1;
}
random_init(entropy_file);
#ifndef CONFIG_NATIVE_WINDOWS
eloop_register_signal(SIGHUP, handle_reload, interfaces);
eloop_register_signal(SIGUSR1, handle_dump_state, interfaces);
#endif /* CONFIG_NATIVE_WINDOWS */
eloop_register_signal_terminate(handle_term, interfaces);
#ifndef CONFIG_NATIVE_WINDOWS
openlog("hostapd", 0, LOG_DAEMON);
#endif /* CONFIG_NATIVE_WINDOWS */
for (i = 0; wpa_drivers[i]; i++)
global.drv_count++;
if (global.drv_count == 0) {
wpa_printf(MSG_ERROR, "No drivers enabled");
return -1;
}
global.drv_priv = os_calloc(global.drv_count, sizeof(void *));
if (global.drv_priv == NULL)
return -1;
return 0;
}
int eloop_register_signal_reconfig(void (*handler)(int sig, void *eloop_ctx,
void *signal_ctx),
void *user_data)
{
#if 0
/* TODO: for example */
return eloop_register_signal(SIGHUP, handler, user_data);
#endif
return 0;
}
/**
* connection_setup_wakeup_main - Tell dbus about our wakeup_main function
* @iface: dbus control interface private data
* Returns: 0 on success, -1 on failure
*
* Register our wakeup_main handler with dbus
*/
static int connection_setup_wakeup_main(struct ctrl_iface_dbus_priv *iface)
{
if (eloop_register_signal(SIGPOLL, process_wakeup_main, iface))
return -1;
dbus_connection_set_wakeup_main_function(iface->con, wakeup_main,
iface, NULL);
return 0;
}
/**
* integrate_with_eloop - Register our mainloop integration with dbus
* @connection: connection to the system message bus
* @priv: a dbus control interface data structure
* Returns: 0 on success, -1 on failure
*/
static int integrate_with_eloop(struct wpas_dbus_priv *priv)
{
if (!dbus_connection_set_watch_functions(priv->con, add_watch,
remove_watch, watch_toggled,
priv, NULL) ||
!dbus_connection_set_timeout_functions(priv->con, add_timeout,
remove_timeout,
timeout_toggled, priv,
NULL)) {
wpa_printf(MSG_ERROR, "dbus: Failed to set callback functions");
return -1;
}
if (eloop_register_signal(SIGPOLL, process_wakeup_main, priv))
return -1;
dbus_connection_set_wakeup_main_function(priv->con, wakeup_main,
priv, NULL);
return 0;
}
int main(int argc, char *argv[])
{
struct wpa_supplicant wpa_s;
u8 pmk[PMK_LEN];
int ret = 1;
if (argc == 2 && strcmp(argv[1], "scard") == 0) {
return scard_test();
}
if (argc < 4) {
printf("usage: eapol_test <conf> <auth srv IP> <secret>\n");
return -1;
}
eloop_init(&wpa_s);
memset(&wpa_s, 0, sizeof(wpa_s));
wpa_s.conf = wpa_config_read(argv[1]);
if (wpa_s.conf == NULL) {
printf("Failed to parse configuration file '%s'.\n", argv[1]);
return -1;
}
if (wpa_s.conf->ssid == NULL) {
printf("No networks defined.\n");
return -1;
}
wpa_init_conf(&wpa_s, argv[2], argv[3]);
if (wpa_supplicant_ctrl_iface_init(&wpa_s)) {
printf("Failed to initialize control interface '%s'.\n"
"You may have another eapol_test process already "
"running or the file was\n"
"left by an unclean termination of eapol_test in "
"which case you will need\n"
"to manually remove this file before starting "
"eapol_test again.\n",
wpa_s.conf->ctrl_interface);
return -1;
}
wpa_supplicant_scard_init(&wpa_s, wpa_s.conf->ssid);
if (test_eapol(&wpa_s, wpa_s.conf->ssid))
return -1;
eloop_register_timeout(30, 0, eapol_test_timeout, &wpa_s, NULL);
eloop_register_timeout(0, 0, send_eap_request_identity, &wpa_s, NULL);
eloop_register_signal(SIGINT, eapol_test_terminate, NULL);
eloop_register_signal(SIGTERM, eapol_test_terminate, NULL);
eloop_register_signal(SIGHUP, eapol_test_terminate, NULL);
eloop_run();
if (eapol_sm_get_key(wpa_s.eapol, pmk, PMK_LEN) == 0) {
wpa_hexdump(MSG_DEBUG, "PMK from EAPOL", pmk, PMK_LEN);
if (memcmp(pmk, wpa_s.authenticator_pmk, PMK_LEN) != 0)
printf("WARNING: PMK mismatch\n");
else if (wpa_s.radius_access_accept_received)
ret = 0;
} else if (wpa_s.authenticator_pmk_len == 16 &&
eapol_sm_get_key(wpa_s.eapol, pmk, 16) == 0) {
wpa_hexdump(MSG_DEBUG, "LEAP PMK from EAPOL", pmk, 16);
if (memcmp(pmk, wpa_s.authenticator_pmk, 16) != 0)
printf("WARNING: PMK mismatch\n");
else if (wpa_s.radius_access_accept_received)
ret = 0;
} else if (wpa_s.radius_access_accept_received && argc > 4) {
/* No keying material expected */
ret = 0;
}
if (wpa_s.auth_timed_out)
ret = -2;
if (wpa_s.radius_access_reject_received)
ret = -3;
test_eapol_clean(&wpa_s);
eloop_destroy();
return ret;
}
int main(int argc, char *argv[])
{
struct hapd_interfaces interfaces;
int ret = 1, i, j;
int c, debug = 0, daemonize = 0;
#ifdef JUMPSTART
char *js_passwd = NULL;
#endif
for (;;) {
c = getopt(argc, argv, "BdhKtvj:");
if (c < 0)
break;
switch (c) {
case 'h':
usage();
break;
case 'd':
debug++;
break;
case 'B':
daemonize++;
break;
case 'K':
wpa_debug_show_keys++;
break;
case 't':
wpa_debug_timestamp++;
break;
case 'v':
show_version();
exit(1);
break;
#ifdef JUMPSTART
case 'j':
js_passwd = optarg;
break;
#endif
default:
usage();
break;
}
}
if (optind == argc)
usage();
register_drivers(); /* NB: generated by Makefile */
interfaces.count = argc - optind;
interfaces.hapd = malloc(interfaces.count * sizeof(hostapd *));
if (interfaces.hapd == NULL) {
printf("malloc failed\n");
exit(1);
}
eloop_init(&interfaces);
eloop_register_signal(SIGHUP, handle_reload, NULL);
eloop_register_signal(SIGINT, handle_term, NULL);
eloop_register_signal(SIGTERM, handle_term, NULL);
eloop_register_signal(SIGUSR1, handle_dump_state, NULL);
for (i = 0; i < interfaces.count; i++) {
printf("Configuration file: %s\n", argv[optind + i]);
#ifdef JUMPSTART
interfaces.hapd[i] = hostapd_init(argv[optind + i], js_passwd);
#else
interfaces.hapd[i] = hostapd_init(argv[optind + i]);
#endif
if (!interfaces.hapd[i])
goto out;
for (j = 0; j < debug; j++) {
if (interfaces.hapd[i]->conf->logger_stdout_level > 0)
interfaces.hapd[i]->conf->
logger_stdout_level--;
interfaces.hapd[i]->conf->debug++;
}
if (hostapd_setup_interface(interfaces.hapd[i]))
goto out;
wpa_debug_level -= interfaces.hapd[0]->conf->debug;
}
if (daemonize && daemon(0, 0)) {
perror("daemon");
goto out;
}
openlog("hostapd", 0, LOG_DAEMON);
eloop_run();
for (i = 0; i < interfaces.count; i++) {
hostapd_free_stas(interfaces.hapd[i]);
hostapd_flush_old_stations(interfaces.hapd[i]);
}
ret = 0;
out:
for (i = 0; i < interfaces.count; i++) {
if (!interfaces.hapd[i])
continue;
hostapd_cleanup(interfaces.hapd[i]);
free(interfaces.hapd[i]);
}
free(interfaces.hapd);
eloop_destroy();
closelog();
driver_unregister_all();
return ret;
}
int main(int argc, char *argv[])
{
struct hapd_interfaces interfaces;
pid_t child_pid;
int ret = 1, i;
int c;
for (;;)
{
c = getopt(argc, argv, "h");
if (c < 0)
break;
switch (c)
{
case 'h':
usage();
break;
default:
break;
}
}
child_pid = 0;
if (child_pid == 0)
{
openlog("rt2500apd",0,LOG_DAEMON);
// set number of configuration file 1
interfaces.count = 1;
interfaces.rtapd = malloc(sizeof(rtapd *));
if (interfaces.rtapd == NULL)
{
DBGPRINT(RT_DEBUG_ERROR,"malloc failed\n");
exit(1);
}
eloop_init(&interfaces);
eloop_register_signal(SIGINT, Handle_term, NULL);
eloop_register_signal(SIGTERM, Handle_term, NULL);
eloop_register_signal(SIGUSR1, Handle_usr1, NULL);
eloop_register_signal(SIGHUP, Handle_usr1, NULL);
DBGPRINT(RT_DEBUG_ERROR,"\n Configuration file: %s\n", RT2500AP_SYSTEM_PATH);
interfaces.rtapd[0] = Apd_init(strdup(RT2500AP_SYSTEM_PATH),(int)getpid());
if (!interfaces.rtapd[0])
goto out;
if (Apd_setup_interface(interfaces.rtapd[0]))
goto out;
eloop_run();
Apd_free_stas(interfaces.rtapd[0]);
ret = 0;
out:
for (i = 0; i < interfaces.count; i++)
{
if (!interfaces.rtapd[i])
continue;
Apd_cleanup(interfaces.rtapd[i]);
free(interfaces.rtapd[i]);
}
free(interfaces.rtapd);
eloop_destroy();
closelog();
return ret;
}
else
return 0;
}
int main(int argc, char *argv[])
{
struct hapd_interfaces interfaces;
pid_t child_pid;
int ret = 1, i;
int c;
pid_t auth_pid;
char prefix_name[IFNAMSIZ+1];
printf("program name = '%s'\n", argv[0]);
if (strstr(argv[0], "8021xdi"))
{
printf("1program name = '%s'\n", argv[0]);
strcpy(prefix_name, "rai");
}
else
{
printf("2program name = '%s'\n", argv[0]);
strcpy(prefix_name, "ra");
}
for (;;)
{
c = getopt(argc, argv, "d:i:h");
if (c < 0)
break;
switch (c)
{
case 'd':
/* set Debug level -
RT_DEBUG_OFF 0
RT_DEBUG_ERROR 1
RT_DEBUG_WARN 2
RT_DEBUG_TRACE 3
RT_DEBUG_INFO 4
*/
printf("Set debug level as %s\n", optarg);
RTDebugLevel = (int)strtol(optarg, 0, 10);
break;
#if 1 /* FIXME: original prefix name seems wrong. */
case 'i':
// Assign the wireless interface when support multiple cards
sprintf(prefix_name, "%s", optarg);
break;
#else
case 'i':
// Assign the wireless interface when support multiple cards
sprintf(prefix_name, "%s%02d_", prefix_name, ((int)strtol(optarg, 0, 10) - 1));
break;
#endif
case 'h':
default:
usage();
break;
}
}
printf("Ralink DOT1X daemon, version = '%s' \n", dot1x_version);
DBGPRINT(RT_DEBUG_TRACE, "prefix_name = '%s'\n", prefix_name);
child_pid = fork();
if (child_pid == 0)
{
auth_pid = getpid();
DBGPRINT(RT_DEBUG_TRACE, "Porcess ID = %d\n",auth_pid);
openlog("rtdot1xd",0,LOG_DAEMON);
// set number of configuration file 1
interfaces.count = 1;
interfaces.rtapd = malloc(sizeof(rtapd *));
if (interfaces.rtapd == NULL)
{
DBGPRINT(RT_DEBUG_ERROR,"malloc failed\n");
exit(1);
}
eloop_init(&interfaces);
eloop_register_signal(SIGINT, Handle_term, NULL);
eloop_register_signal(SIGTERM, Handle_term, NULL);
eloop_register_signal(SIGUSR1, Handle_usr1, NULL);
eloop_register_signal(SIGHUP, Handle_usr1, NULL);
interfaces.rtapd[0] = Apd_init(prefix_name);
if (!interfaces.rtapd[0])
goto out;
if (Apd_setup_interface(interfaces.rtapd[0]))
goto out;
// Notify driver about PID
RT_ioctl(interfaces.rtapd[0]->ioctl_sock, RT_PRIV_IOCTL, (char *)&auth_pid, sizeof(int), prefix_name, 0, RT_SET_APD_PID | OID_GET_SET_TOGGLE);
eloop_run();
Apd_free_stas(interfaces.rtapd[0]);
ret = 0;
out:
for (i = 0; i < interfaces.count; i++)
{
if (!interfaces.rtapd[i])
continue;
Apd_cleanup(interfaces.rtapd[i]);
free(interfaces.rtapd[i]);
}
free(interfaces.rtapd);
eloop_destroy();
closelog();
return ret;
}
else
return 0;
}
CSCM_EXPORT int eap_supplicant_authenticate (
u8 *MSK_buffer,
size_t MSK_buffer_len,
int wimax_mode,
int generate_eap_request_identity)
{
int ret = EAP_SUPPLICANT_STARTED;
wpa_printf(MSG_DEBUG, "Entering eap_supplicant_authenticate\n");
// Initialize EAPOL sm and other structures
if (test_eapol(&eapol_test, &wpa_s, wpa_s.conf->ssid))
return EAP_SUPPLICANT_TEST_EAPOL_FAILED;
wpa_printf(MSG_DEBUG, "After test_eapol\n");
#ifdef UNUSED_CODE
if (wait_for_monitor)
wpa_supplicant_ctrl_iface_wait(&wpa_s);
#endif
p_eapol_test->radius_access_accept_received = 0;
// Set up for authentication
eloop_clear_terminate();
eloop_register_timeout(eapol_test.authentication_timeout_sec, 0,
eapol_test_timeout, &eapol_test, NULL);
if (generate_eap_request_identity)
eloop_register_timeout(0, 0, send_eap_request_identity, &wpa_s, NULL);
eloop_register_signal(SIGINT, eapol_test_terminate, NULL);
eloop_register_signal(SIGTERM, eapol_test_terminate, NULL);
#ifndef CONFIG_NATIVE_WINDOWS
eloop_register_signal(SIGHUP, eapol_test_terminate, NULL);
#endif /* CONFIG_NATIVE_WINDOWS */
wpa_printf(MSG_DEBUG, "After eloop setup calls\n");
ieee802_1x_rx_is_ready = 1;
eloop_run(wimax_mode);
ieee802_1x_rx_is_ready = 0;
wpa_printf(MSG_DEBUG, "After eloop_run\n");
memset(MSK_buffer, 0, MSK_buffer_len);
if (eapol_test.auth_timed_out)
ret = EAP_SUPPLICANT_TIMED_OUT;
else if (eapol_test.radius_access_reject_received)
ret = EAP_SUPPLICANT_RADIUS_ACCESS_REJECT_RECEIVED;
else if (wimax_mode) {
ret = eapol_sm_get_key(eapol_test.wpa_s->eapol, MSK_buffer, MSK_buffer_len);
wpa_printf(MSG_DEBUG, "eapol_sm_get_key returned %d\n", ret);
if (ret)
ret = EAP_SUPPLICANT_SM_GET_KEY_FAILED;
else
ret = EAP_SUPPLICANT_SUCCESS;
}
else {
if (eapol_test_compare_pmk(&eapol_test) == 0 &&
eapol_sm_get_key(eapol_test.wpa_s->eapol, MSK_buffer, MSK_buffer_len) == 0)
ret = EAP_SUPPLICANT_SUCCESS;
else
ret = EAP_SUPPLICANT_SM_GET_KEY_FAILED;
}
if (ret == EAP_SUPPLICANT_SUCCESS)
{
wpa_printf(MSG_DEBUG, "MSK before reordering");
wpa_hexdump(MSG_DEBUG, "MSK[ 0-15] = ", MSK_buffer + 0, 16);
wpa_hexdump(MSG_DEBUG, "MSK[16-31] = ", MSK_buffer + 16, 16);
wpa_hexdump(MSG_DEBUG, "MSK[31-47] = ", MSK_buffer + 32, 16);
wpa_hexdump(MSG_DEBUG, "MSK[48-63] = ", MSK_buffer + 48, 16);
wpa_printf(MSG_DEBUG, "MSK len = %d\n", MSK_buffer_len);
}
if (!wimax_mode) {
wpa_printf(MSG_ERROR, "MPPE keys OK: %d mismatch: %d\n",
eapol_test.num_mppe_ok, eapol_test.num_mppe_mismatch);
if (ret == EAP_SUPPLICANT_SUCCESS && eapol_test.num_mppe_mismatch)
ret = EAP_SUPPLICANT_NUM_MPPE_MISMATCH;
}
if (ret)
wpa_printf(MSG_ERROR, "FAILURE (ret code = %d)\n", ret);
else
wpa_printf(MSG_ERROR, "SUCCESS\n");
return ret;
}
int main(int argc, char *argv[])
{
struct wpa_supplicant wpa_s;
int c, ret = 1, wait_for_monitor = 0, save_config = 0;
char *as_addr = "127.0.0.1";
int as_port = 1812;
char *as_secret = "radius";
char *conf = NULL;
#ifdef CONFIG_NATIVE_WINDOWS
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 0), &wsaData)) {
printf("Could not find a usable WinSock.dll\n");
return -1;
}
#endif /* CONFIG_NATIVE_WINDOWS */
memset(&eapol_test, 0, sizeof(eapol_test));
wpa_debug_level = 0;
wpa_debug_show_keys = 1;
for (;;) {
c = getopt(argc, argv, "a:c:np:r:s:SW");
if (c < 0)
break;
switch (c) {
case 'a':
as_addr = optarg;
break;
case 'c':
conf = optarg;
break;
case 'n':
eapol_test.no_mppe_keys++;
break;
case 'p':
as_port = atoi(optarg);
break;
case 'r':
eapol_test.eapol_test_num_reauths = atoi(optarg);
break;
case 's':
as_secret = optarg;
break;
case 'S':
save_config++;
break;
case 'W':
wait_for_monitor++;
break;
default:
usage();
return -1;
}
}
if (argc > optind && strcmp(argv[optind], "scard") == 0) {
return scard_test();
}
if (argc > optind && strcmp(argv[optind], "sim") == 0) {
return scard_get_triplets(argc - optind - 1,
&argv[optind + 1]);
}
if (conf == NULL) {
usage();
printf("Configuration file is required.\n");
return -1;
}
eloop_init(&wpa_s);
memset(&wpa_s, 0, sizeof(wpa_s));
eapol_test.wpa_s = &wpa_s;
wpa_s.conf = wpa_config_read(conf);
if (wpa_s.conf == NULL) {
printf("Failed to parse configuration file '%s'.\n", conf);
return -1;
}
if (wpa_s.conf->ssid == NULL) {
printf("No networks defined.\n");
return -1;
}
wpa_init_conf(&eapol_test, &wpa_s, as_addr, as_port, as_secret);
if (wpa_supplicant_ctrl_iface_init(&wpa_s)) {
printf("Failed to initialize control interface '%s'.\n"
"You may have another eapol_test process already "
"running or the file was\n"
"left by an unclean termination of eapol_test in "
"which case you will need\n"
"to manually remove this file before starting "
"eapol_test again.\n",
wpa_s.conf->ctrl_interface);
return -1;
}
if (wpa_supplicant_scard_init(&wpa_s, wpa_s.conf->ssid))
return -1;
if (test_eapol(&eapol_test, &wpa_s, wpa_s.conf->ssid))
return -1;
if (wait_for_monitor)
wpa_supplicant_ctrl_iface_wait(&wpa_s);
eloop_register_timeout(30, 0, eapol_test_timeout, &eapol_test, NULL);
eloop_register_timeout(0, 0, send_eap_request_identity, &wpa_s, NULL);
eloop_register_signal(SIGINT, eapol_test_terminate, NULL);
eloop_register_signal(SIGTERM, eapol_test_terminate, NULL);
#ifndef CONFIG_NATIVE_WINDOWS
eloop_register_signal(SIGHUP, eapol_test_terminate, NULL);
#endif /* CONFIG_NATIVE_WINDOWS */
eloop_run();
if (eapol_test_compare_pmk(&eapol_test) == 0)
ret = 0;
if (eapol_test.auth_timed_out)
ret = -2;
if (eapol_test.radius_access_reject_received)
ret = -3;
if (save_config)
wpa_config_write(conf, wpa_s.conf);
test_eapol_clean(&eapol_test, &wpa_s);
eloop_destroy();
printf("MPPE keys OK: %d mismatch: %d\n",
eapol_test.num_mppe_ok, eapol_test.num_mppe_mismatch);
if (eapol_test.num_mppe_mismatch)
ret = -4;
if (ret)
printf("FAILURE\n");
else
printf("SUCCESS\n");
#ifdef CONFIG_NATIVE_WINDOWS
WSACleanup();
#endif /* CONFIG_NATIVE_WINDOWS */
return ret;
}
int
main(int argc, char *argv[])
{
struct wpa_supplicant wpa_s;
char *link = NULL;
char *key = NULL;
dlpi_handle_t dh = NULL;
datalink_id_t linkid;
dladm_phys_attr_t dpa;
int c;
int exitcode;
char door_file[WPA_STRSIZE];
for (;;) {
c = getopt(argc, argv, "Dk:hi:v");
if (c < 0)
break;
switch (c) {
case 'D':
wpa_debug_level = MSG_DEBUG;
break;
case 'h':
usage();
return (-1);
case 'i':
link = optarg;
break;
case 'k':
key = optarg;
break;
case 'v':
(void) printf("%s\n", wpa_supplicant_version);
return (-1);
default:
usage();
return (-1);
}
}
/*
* key name is required to retrieve PSK value through libwdladm APIs.
* key is saved by dladm command by keyname
* see dladm.
*/
if ((link == NULL) || (key == NULL)) {
wpa_printf(MSG_ERROR, "\nLink & key is required.");
return (-1);
}
if ((strlen(key) >= sizeof (wpa_s.kname))) {
wpa_printf(MSG_ERROR, "Too long key name '%s'.", key);
return (-1);
}
if (daemon(0, 0))
return (-1);
/*
* Hold this link open to prevent a link renaming operation.
*/
if (dlpi_open(link, &dh, 0) != DLPI_SUCCESS) {
wpa_printf(MSG_ERROR, "Failed to open link '%s'.", link);
return (-1);
}
if (dladm_name2info(link, &linkid, NULL, NULL, NULL) !=
DLADM_STATUS_OK) {
wpa_printf(MSG_ERROR, "Invalid link name '%s'.", link);
dlpi_close(dh);
return (-1);
}
/*
* Get the device name of the link, which will be used as the door
* file name used to communicate with the driver. Note that different
* links use different doors.
*/
if (dladm_phys_info(linkid, &dpa, DLADM_OPT_ACTIVE) !=
DLADM_STATUS_OK) {
wpa_printf(MSG_ERROR,
"Failed to get device name of link '%s'.", link);
dlpi_close(dh);
return (-1);
}
(void) snprintf(door_file, WPA_STRSIZE, "%s_%s", WPA_DOOR, dpa.dp_dev);
(void) memset(&wpa_s, 0, sizeof (wpa_s));
wpa_s.driver = &wpa_driver_wifi_ops;
wpa_s.linkid = linkid;
(void) strlcpy(wpa_s.kname, key, sizeof (wpa_s.kname));
eloop_init(&wpa_s);
/*
* Setup default WPA/WPA2 configuration
* get ESSID and PSK value
*/
wpa_s.conf = wpa_config_read(&wpa_s);
if (wpa_s.conf == NULL || wpa_s.conf->ssid == NULL) {
wpa_printf(MSG_ERROR, "\nNo networks (SSID) configured.\n");
exitcode = -1;
goto cleanup;
}
exitcode = 0;
/*
* Setup door file to communicate with driver
*/
if (wpa_supplicant_door_setup(&wpa_s, door_file) != 0) {
wpa_printf(MSG_ERROR, "Failed to setup door(%s)", door_file);
exitcode = -1;
goto cleanup;
}
wpa_s.renew_snonce = 1;
if (wpa_supplicant_driver_init(link, &wpa_s) < 0) {
exitcode = -1;
goto cleanup;
}
/*
* This link is hold again in wpa_supplicant_driver_init(), so that
* we release the first reference.
*/
dlpi_close(dh);
dh = NULL;
wpa_printf(MSG_DEBUG, "=> eloop_run");
(void) eloop_register_signal(SIGINT, wpa_supplicant_terminate, NULL);
(void) eloop_register_signal(SIGTERM, wpa_supplicant_terminate, NULL);
(void) eloop_register_signal(SIGKILL, wpa_supplicant_terminate, NULL);
eloop_run();
wpa_printf(MSG_DEBUG, "<= eloop_run()");
wpa_supplicant_disassociate(&wpa_s, REASON_DEAUTH_LEAVING);
if (wpa_s.driver->set_wpa(wpa_s.linkid, 0) < 0) {
wpa_printf(MSG_ERROR, "Failed to disable WPA in the driver.\n");
}
cleanup:
wpa_supplicant_door_destroy(door_file);
wpa_supplicant_cleanup(&wpa_s);
eloop_destroy();
if (dh != NULL)
dlpi_close(dh);
return (exitcode);
}
int main(int argc, char *argv[])
{
struct hapd_interfaces interfaces;
int ret = 1, i, j;
int c, debug = 0, daemonize = 0;
for (;;) {
c = getopt(argc, argv, "Bdh");
if (c < 0)
break;
switch (c) {
case 'h':
usage();
break;
case 'd':
debug++;
break;
case 'B':
daemonize++;
break;
default:
usage();
break;
}
}
if (optind == argc)
usage();
interfaces.count = argc - optind;
interfaces.hapd = malloc(interfaces.count * sizeof(hostapd *));
if (interfaces.hapd == NULL) {
printf("malloc failed\n");
exit(1);
}
eloop_init(&interfaces);
eloop_register_signal(SIGHUP, handle_reload, NULL);
eloop_register_signal(SIGINT, handle_term, NULL);
eloop_register_signal(SIGTERM, handle_term, NULL);
eloop_register_signal(SIGUSR1, handle_dump_state, NULL);
for (i = 0; i < interfaces.count; i++) {
printf("Configuration file: %s\n", argv[optind + i]);
interfaces.hapd[i] = hostapd_init(argv[optind + i]);
if (!interfaces.hapd[i])
goto out;
for (j = 0; j < debug; j++) {
if (interfaces.hapd[i]->conf->logger_stdout_level > 0)
interfaces.hapd[i]->conf->
logger_stdout_level--;
interfaces.hapd[i]->conf->debug++;
}
hostapd_set_broadcast_wep(interfaces.hapd[i]);
if (hostapd_setup_interface(interfaces.hapd[i]))
goto out;
}
if (daemonize && daemon(0, 0)) {
perror("daemon");
goto out;
}
openlog("hostapd", 0, LOG_DAEMON);
eloop_run();
for (i = 0; i < interfaces.count; i++) {
hostapd_free_stas(interfaces.hapd[i]);
hostapd_flush_old_stations(interfaces.hapd[i]);
}
ret = 0;
out:
for (i = 0; i < interfaces.count; i++) {
if (!interfaces.hapd[i])
continue;
hostapd_cleanup(interfaces.hapd[i]);
free(interfaces.hapd[i]);
}
free(interfaces.hapd);
eloop_destroy();
closelog();
return ret;
}
int main(int argc, char *argv[])
{
struct hapd_interfaces interfaces;
pid_t child_pid;
int ret = 1, i;
int c;
pid_t auth_pid;
for (;;)
{
c = getopt(argc, argv, "h");
if (c < 0)
break;
switch (c)
{
case 'h':
usage();
break;
default:
break;
}
}
child_pid = fork();
if (child_pid == 0)
{
auth_pid = getpid();
DBGPRINT(RT_DEBUG_TRACE, "Porcess ID = %d\n",auth_pid);
openlog("rt61apd",0,LOG_DAEMON);
// set number of configuration file 1
interfaces.count = 1;
interfaces.rtapd = malloc(sizeof(rtapd *));
if (interfaces.rtapd == NULL)
{
DBGPRINT(RT_DEBUG_ERROR,"malloc failed\n");
exit(1);
}
eloop_init(&interfaces);
eloop_register_signal(SIGINT, Handle_term, NULL);
eloop_register_signal(SIGTERM, Handle_term, NULL);
eloop_register_signal(SIGUSR1, Handle_usr1, NULL);
eloop_register_signal(SIGHUP, Handle_usr1, NULL);
DBGPRINT(RT_DEBUG_ERROR,"\n Configuration file: %s\n", RT61AP_SYSTEM_PATH);
interfaces.rtapd[0] = Apd_init(strdup(RT61AP_SYSTEM_PATH),(int)getpid());
if (!interfaces.rtapd[0])
goto out;
if (Apd_setup_interface(interfaces.rtapd[0]))
goto out;
// Notify driver about PID
RT_ioctl(interfaces.rtapd[0], RT_PRIV_IOCTL, (u8*)&auth_pid, sizeof(int), 0, RT_SET_APD_PID | OID_GET_SET_TOGGLE);
eloop_run();
Apd_free_stas(interfaces.rtapd[0]);
ret = 0;
out:
for (i = 0; i < interfaces.count; i++)
{
if (!interfaces.rtapd[i])
continue;
Apd_cleanup(interfaces.rtapd[i]);
free(interfaces.rtapd[i]);
}
free(interfaces.rtapd);
eloop_destroy();
closelog();
return ret;
}
else
return 0;
}