static void wlantest_cli_interactive(int s)
{
struct wlantest_cli cli;
char *home, *hfile = NULL;
if (eloop_init())
return;
home = getenv("HOME");
if (home) {
const char *fname = ".wlantest_cli_history";
int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
hfile = os_malloc(hfile_len);
if (hfile)
os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
}
cli.s = s;
eloop_register_signal_terminate(wlantest_cli_eloop_terminate, &cli);
edit_init(wlantest_cli_edit_cmd_cb, wlantest_cli_edit_eof_cb,
wlantest_cli_edit_completion_cb, &cli, hfile, NULL);
eloop_run();
edit_deinit(hfile, NULL);
os_free(hfile);
eloop_destroy();
}
int main(int argc, char *argv[])
{
struct radius_ctx ctx;
struct hostapd_radius_server *srv;
if (os_program_init())
return -1;
hostapd_logger_register_cb(hostapd_logger_cb);
os_memset(&ctx, 0, sizeof(ctx));
inet_aton("127.0.0.1", &ctx.own_ip_addr);
if (eloop_init()) {
printf("Failed to initialize event loop\n");
return -1;
}
srv = os_zalloc(sizeof(*srv));
if (srv == NULL)
return -1;
srv->addr.af = AF_INET;
srv->port = 1812;
if (hostapd_parse_ip_addr("127.0.0.1", &srv->addr) < 0) {
printf("Failed to parse IP address\n");
return -1;
}
srv->shared_secret = (u8 *) os_strdup("radius");
srv->shared_secret_len = 6;
ctx.conf.auth_server = ctx.conf.auth_servers = srv;
ctx.conf.num_auth_servers = 1;
ctx.conf.msg_dumps = 1;
ctx.radius = radius_client_init(&ctx, &ctx.conf);
if (ctx.radius == NULL) {
printf("Failed to initialize RADIUS client\n");
return -1;
}
if (radius_client_register(ctx.radius, RADIUS_AUTH, receive_auth,
&ctx) < 0) {
printf("Failed to register RADIUS authentication handler\n");
return -1;
}
eloop_register_timeout(0, 0, start_example, &ctx, NULL);
eloop_run();
radius_client_deinit(ctx.radius);
os_free(srv->shared_secret);
os_free(srv);
eloop_destroy();
os_program_deinit();
return 0;
}
static void hostapd_cli_interactive(void)
{
char *hfile = NULL;
char *home;
printf("\nInteractive mode\n\n");
#ifdef CONFIG_HOSTAPD_CLI_HISTORY_DIR
home = CONFIG_HOSTAPD_CLI_HISTORY_DIR;
#else /* CONFIG_HOSTAPD_CLI_HISTORY_DIR */
home = getenv("HOME");
#endif /* CONFIG_HOSTAPD_CLI_HISTORY_DIR */
if (home) {
const char *fname = ".hostapd_cli_history";
int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
hfile = os_malloc(hfile_len);
if (hfile)
os_snprintf(hfile, hfile_len, "%s/%s", home, fname);
}
eloop_register_signal_terminate(hostapd_cli_eloop_terminate, NULL);
edit_init(hostapd_cli_edit_cmd_cb, hostapd_cli_edit_eof_cb,
hostapd_cli_edit_completion_cb, NULL, hfile, NULL);
eloop_register_timeout(ping_interval, 0, hostapd_cli_ping, NULL, NULL);
eloop_run();
cli_txt_list_flush(&stations);
edit_deinit(hfile, NULL);
os_free(hfile);
eloop_cancel_timeout(hostapd_cli_ping, NULL, NULL);
}
static int hostapd_global_run(struct hapd_interfaces *ifaces, int daemonize,
const char *pid_file)
{
#ifdef EAP_SERVER_TNC
int tnc = 0;
size_t i, k;
for (i = 0; !tnc && i < ifaces->count; i++) {
for (k = 0; k < ifaces->iface[i]->num_bss; k++) {
if (ifaces->iface[i]->bss[0]->conf->tnc) {
tnc++;
break;
}
}
}
if (tnc && tncs_global_init() < 0) {
wpa_printf(MSG_ERROR, "Failed to initialize TNCS");
return -1;
}
#endif /* EAP_SERVER_TNC */
eloop_run();
return 0;
}
int hs20_web_browser(const char *url)
{
char cmd[2000];
int ret;
struct http_server *http;
struct in_addr addr;
struct browser_data data;
wpa_printf(MSG_INFO, "Launching wpadebug browser to %s", url);
os_memset(&data, 0, sizeof(data));
ret = os_snprintf(cmd, sizeof(cmd),
"start -a android.action.MAIN "
"-c android.intent.category.LAUNCHER "
"-n w1.fi.wpadebug/.WpaWebViewActivity "
"-e w1.fi.wpadebug.URL '%s'", url);
if (ret < 0 || (size_t) ret >= sizeof(cmd)) {
wpa_printf(MSG_ERROR, "Too long URL");
return -1;
}
if (eloop_init() < 0) {
wpa_printf(MSG_ERROR, "eloop_init failed");
return -1;
}
addr.s_addr = htonl((127 << 24) | 1);
http = http_server_init(&addr, 12345, http_req, &data);
if (http == NULL) {
wpa_printf(MSG_ERROR, "http_server_init failed");
eloop_destroy();
return -1;
}
if (os_exec("/system/bin/am", cmd, 1) != 0) {
wpa_printf(MSG_INFO, "Failed to launch wpadebug browser");
eloop_cancel_timeout(browser_timeout, NULL, NULL);
http_server_deinit(http);
eloop_destroy();
return -1;
}
eloop_register_timeout(300, 0, browser_timeout, &data, NULL);
eloop_run();
eloop_cancel_timeout(browser_timeout, &data, NULL);
http_server_deinit(http);
eloop_destroy();
wpa_printf(MSG_INFO, "Closing Android browser");
if (os_exec("/system/bin/am",
"start -a android.action.MAIN "
"-c android.intent.category.LAUNCHER "
"-n w1.fi.wpadebug/.WpaWebViewActivity "
"-e w1.fi.wpadebug.URL FINISH", 1) != 0) {
wpa_printf(MSG_INFO, "Failed to close wpadebug browser");
}
return data.success;
}
static void* xwifi_run(void* arg)
{
S_;
struct xwifi* instance = (struct xwifi*) arg;
KUNUSED(instance);
eloop_run();
return NULL;
}
int main()
{
int ret;
struct nl_cb * nl_cb;
struct nl_handle * nl_handle;
struct netlink_data * netlink;
int ioctl_sock = -1;
struct dl_list interfaces;
int if_add_ifindex = -1;
dl_list_init(&interfaces);
/*
* global_init
*/
ret = netlink_init_nl80211_event_rtm(&netlink,NULL,nl80211_event_rtm_newlink,nl80211_event_rtm_dellink);
if (ret == -1 || netlink == NULL)
{
goto err;
}
ret = nl80211_init_event(&nl_cb, &nl_handle);
if (ret == -1)
{
wpa_printf(MSG_DEBUG, "nl80211: Init failure ");
goto err;
}
wpa_printf(MSG_INFO, "nl80211: wait for event... ");
nl_cb_set(nl_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM,
no_seq_check, NULL);
nl_cb_set(nl_cb, NL_CB_VALID, NL_CB_CUSTOM,
process_event, NULL);
eloop_register_wrapper(nl_socket_get_fd(nl_handle),
nl80211_event_receive,
nl_cb, nl_handle);
ioctl_sock = init_ioctl_sock();
if (ioctl_sock < 0)
{
perror("socket(PF_INET,SOCK_DGRAM)");
goto err;
}
/*
* hapd_init
*/
eloop_run();
return 0;
err:
netlink_deinit(netlink);
nl_destroy_handles(&nl_handle);
nl_cb_put(nl_cb);
if (ioctl_sock >= 0)
{
close(ioctl_sock);
}
return -1;
}
int hs20_web_browser(const char *url)
{
struct http_server *http;
struct in_addr addr;
struct browser_data data;
pid_t pid;
wpa_printf(MSG_INFO, "Launching system browser to %s", url);
os_memset(&data, 0, sizeof(data));
if (eloop_init() < 0) {
wpa_printf(MSG_ERROR, "eloop_init failed");
return -1;
}
addr.s_addr = htonl((127 << 24) | 1);
http = http_server_init(&addr, 12345, http_req, &data);
if (http == NULL) {
wpa_printf(MSG_ERROR, "http_server_init failed");
eloop_destroy();
return -1;
}
pid = fork();
if (pid < 0) {
wpa_printf(MSG_ERROR, "fork: %s", strerror(errno));
http_server_deinit(http);
eloop_destroy();
return -1;
}
if (pid == 0) {
/* run the external command in the child process */
char *argv[3];
argv[0] = "browser-system";
argv[1] = (void *)url;
argv[2] = NULL;
execv("/usr/bin/x-www-browser", argv);
wpa_printf(MSG_ERROR, "execv: %s", strerror(errno));
exit(0);
return -1;
}
eloop_register_timeout(120, 0, browser_timeout, &data, NULL);
eloop_run();
eloop_cancel_timeout(browser_timeout, &data, NULL);
http_server_deinit(http);
eloop_destroy();
/* TODO: Close browser */
return data.success;
}
static void hostapd_cli_interactive(void)
{
printf("\nInteractive mode\n\n");
eloop_register_signal_terminate(hostapd_cli_eloop_terminate, NULL);
edit_init(hostapd_cli_edit_cmd_cb, hostapd_cli_edit_eof_cb,
NULL, NULL, NULL, NULL);
eloop_register_timeout(ping_interval, 0, hostapd_cli_ping, NULL, NULL);
eloop_run();
edit_deinit(NULL, NULL);
eloop_cancel_timeout(hostapd_cli_ping, NULL, NULL);
}
static void Cyg_DOT1X(cyg_addrword_t param)
#endif //__ECOS//
{
int ret = 1, i;
pid_t auth_pid=1;
char prefix_name[IFNAMSIZ+1];
strcpy(prefix_name, "ra");
DBGPRINT(RT_DEBUG_ERROR,"Start DOT1X Thread....\n");
// 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);
interfaces.rtapd[0] = Apd_init(prefix_name);
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);
interfaces.rtapd = NULL;
eloop_destroy();
DBGPRINT(RT_DEBUG_ERROR,"DOT1X_exit\n");
cyg_thread_exit();
return 0;
}
int main(int argc, char *argv[])
{
struct wpa wpa;
if (os_program_init())
return -1;
os_memset(&wpa, 0, sizeof(wpa));
os_memset(wpa.auth_addr, 0x12, ETH_ALEN);
os_memset(wpa.supp_addr, 0x32, ETH_ALEN);
os_memset(wpa.psk, 0x44, PMK_LEN);
wpa_debug_level = 0;
wpa_debug_show_keys = 1;
if (eloop_init()) {
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
return -1;
}
if (auth_init_group(&wpa) < 0)
return -1;
if (supp_init(&wpa) < 0)
return -1;
if (auth_init(&wpa) < 0)
return -1;
wpa_printf(MSG_DEBUG, "Starting eloop");
eloop_run();
wpa_printf(MSG_DEBUG, "eloop done");
deinit(&wpa);
eloop_destroy();
os_program_deinit();
return 0;
}
int hostapd_global_run(struct hostapd_iface *ifaces)
{
#ifdef EAP_SERVER_TNC
int tnc = 0;
size_t i, k;
for (k = 0; k < ifaces->iface[i]->num_bss; k++) {
if (ifaces->iface[i]->bss[0]->conf->tnc) {
tnc++;
break;
}
}
if (tnc && tncs_global_init() < 0) {
wpa_printf(MSG_ERROR, "Failed to initialize TNCS");
return -1;
}
#endif /* EAP_SERVER_TNC */
eloop_run();
return 0;
}
int main(int argc, char *argv[])
{
struct wpa_supplicant wpa_s;
int ret = 1;
u8 bssid[ETH_ALEN];
struct preauth_test_data preauth_test;
if (os_program_init())
return -1;
os_memset(&preauth_test, 0, sizeof(preauth_test));
wpa_debug_level = 0;
wpa_debug_show_keys = 1;
if (argc != 4) {
printf("usage: preauth_test <conf> <target MAC address> "
"<ifname>\n");
return -1;
}
if (hwaddr_aton(argv[2], bssid)) {
printf("Failed to parse target address '%s'.\n", argv[2]);
return -1;
}
if (eap_register_methods()) {
wpa_printf(MSG_ERROR, "Failed to register EAP methods");
return -1;
}
#ifdef WAPI
if (eloop_init(&wpa_s)) {
#else
if (eloop_init()) {
#endif
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
return -1;
}
os_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[3]);
wpa_s.ctrl_iface = wpa_supplicant_ctrl_iface_init(&wpa_s);
if (wpa_s.ctrl_iface == NULL) {
printf("Failed to initialize control interface '%s'.\n"
"You may have another preauth_test process already "
"running or the file was\n"
"left by an unclean termination of preauth_test in "
"which case you will need\n"
"to manually remove this file before starting "
"preauth_test again.\n",
wpa_s.conf->ctrl_interface);
return -1;
}
if (wpa_supplicant_scard_init(&wpa_s, wpa_s.conf->ssid))
return -1;
if (rsn_preauth_init(wpa_s.wpa, bssid, &wpa_s.conf->ssid->eap))
return -1;
eloop_register_timeout(30, 0, eapol_test_timeout, &preauth_test, NULL);
eloop_register_timeout(0, 100000, eapol_test_poll, &wpa_s, NULL);
eloop_register_signal_terminate(eapol_test_terminate, &wpa_s);
eloop_register_signal_reconfig(eapol_test_terminate, &wpa_s);
eloop_run();
if (preauth_test.auth_timed_out)
ret = -2;
else {
ret = pmksa_cache_set_current(wpa_s.wpa, NULL, bssid, NULL, 0)
? 0 : -3;
}
test_eapol_clean(&wpa_s);
eap_peer_unregister_methods();
eloop_destroy();
os_program_deinit();
return ret;
}
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 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 *cli_addr = NULL;
char *conf = NULL;
int timeout = 30;
char *pos;
struct extra_radius_attr *p = NULL, *p1;
if (os_program_init())
return -1;
hostapd_logger_register_cb(hostapd_logger_cb);
os_memset(&eapol_test, 0, sizeof(eapol_test));
eapol_test.connect_info = "CONNECT 11Mbps 802.11b";
os_memcpy(eapol_test.own_addr, "\x02\x00\x00\x00\x00\x01", ETH_ALEN);
wpa_debug_level = 0;
wpa_debug_show_keys = 1;
for (;;) {
c = getopt(argc, argv, "a:A:c:C:M:nN:o:p:r:s:St:W");
if (c < 0)
break;
switch (c) {
case 'a':
as_addr = optarg;
break;
case 'A':
cli_addr = optarg;
break;
case 'c':
conf = optarg;
break;
case 'C':
eapol_test.connect_info = optarg;
break;
case 'M':
if (hwaddr_aton(optarg, eapol_test.own_addr)) {
usage();
return -1;
}
break;
case 'n':
eapol_test.no_mppe_keys++;
break;
case 'o':
if (eapol_test.server_cert_file)
fclose(eapol_test.server_cert_file);
eapol_test.server_cert_file = fopen(optarg, "w");
if (eapol_test.server_cert_file == NULL) {
printf("Could not open '%s' for writing\n",
optarg);
return -1;
}
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 't':
timeout = atoi(optarg);
break;
case 'W':
wait_for_monitor++;
break;
case 'N':
p1 = os_zalloc(sizeof(p1));
if (p1 == NULL)
break;
if (!p)
eapol_test.extra_attrs = p1;
else
p->next = p1;
p = p1;
p->type = atoi(optarg);
pos = os_strchr(optarg, ':');
if (pos == NULL) {
p->syntax = 'n';
p->data = NULL;
break;
}
pos++;
if (pos[0] == '\0' || pos[1] != ':') {
printf("Incorrect format of attribute "
"specification\n");
break;
}
p->syntax = pos[0];
p->data = pos + 2;
break;
default:
usage();
return -1;
}
}
if (argc > optind && os_strcmp(argv[optind], "scard") == 0) {
return scard_test();
}
if (argc > optind && os_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;
}
if (eap_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;
}
os_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,
cli_addr);
wpa_s.ctrl_iface = wpa_supplicant_ctrl_iface_init(&wpa_s);
if (wpa_s.ctrl_iface == NULL) {
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.ctrl_iface);
eloop_register_timeout(timeout, 0, eapol_test_timeout, &eapol_test,
NULL);
eloop_register_timeout(0, 0, send_eap_request_identity, &wpa_s, NULL);
eloop_register_signal_terminate(eapol_test_terminate, &wpa_s);
eloop_register_signal_reconfig(eapol_test_terminate, &wpa_s);
eloop_run();
eloop_cancel_timeout(eapol_test_timeout, &eapol_test, NULL);
eloop_cancel_timeout(eapol_sm_reauth, &eapol_test, NULL);
if (eapol_test_compare_pmk(&eapol_test) == 0 ||
eapol_test.no_mppe_keys)
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);
eap_peer_unregister_methods();
#ifdef CONFIG_AP
eap_server_unregister_methods();
#endif /* CONFIG_AP */
eloop_destroy();
if (eapol_test.server_cert_file)
fclose(eapol_test.server_cert_file);
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");
os_program_deinit();
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[])
{
int c, i;
int ret = -1;
char *pid_file = NULL;
int daemonize = 0;
char *ctrl_dir = "/var/run/wpa_priv";
struct wpa_priv_interface *interfaces = NULL, *iface;
if (os_program_init())
return -1;
wpa_priv_fd_workaround();
for (;;) {
c = getopt(argc, argv, "Bc:dP:");
if (c < 0)
break;
switch (c) {
case 'B':
daemonize++;
break;
case 'c':
ctrl_dir = optarg;
break;
case 'd':
wpa_debug_level--;
break;
case 'P':
pid_file = os_rel2abs_path(optarg);
break;
default:
usage();
goto out;
}
}
if (optind >= argc) {
usage();
goto out;
}
wpa_printf(MSG_DEBUG, "wpa_priv control directory: '%s'", ctrl_dir);
if (eloop_init(NULL)) {
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
goto out;
}
for (i = optind; i < argc; i++) {
wpa_printf(MSG_DEBUG, "Adding driver:interface %s", argv[i]);
iface = wpa_priv_interface_init(ctrl_dir, argv[i]);
if (iface == NULL)
goto out;
iface->next = interfaces;
interfaces = iface;
}
if (daemonize && os_daemonize(pid_file))
goto out;
eloop_register_signal_terminate(wpa_priv_terminate, NULL);
eloop_run();
ret = 0;
out:
iface = interfaces;
while (iface) {
struct wpa_priv_interface *prev = iface;
iface = iface->next;
wpa_priv_interface_deinit(prev);
}
eloop_destroy();
os_daemonize_terminate(pid_file);
os_free(pid_file);
os_program_deinit();
return ret;
}
int hs20_web_browser(const char *url)
{
struct http_server *http;
struct in_addr addr;
struct browser_data data;
pid_t pid;
wpa_printf(MSG_INFO, "Launching wpadebug browser to %s", url);
os_memset(&data, 0, sizeof(data));
if (eloop_init() < 0) {
wpa_printf(MSG_ERROR, "eloop_init failed");
return -1;
}
addr.s_addr = htonl((127 << 24) | 1);
http = http_server_init(&addr, 12345, http_req, &data);
if (http == NULL) {
wpa_printf(MSG_ERROR, "http_server_init failed");
eloop_destroy();
return -1;
}
pid = fork();
if (pid < 0) {
wpa_printf(MSG_ERROR, "fork: %s", strerror(errno));
http_server_deinit(http);
eloop_destroy();
return -1;
}
if (pid == 0) {
/* run the external command in the child process */
char *argv[14];
argv[0] = "browser-wpadebug";
argv[1] = "start";
argv[2] = "-a";
argv[3] = "android.action.MAIN";
argv[4] = "-c";
argv[5] = "android.intent.category.LAUNCHER";
argv[6] = "-n";
argv[7] = "w1.fi.wpadebug/.WpaWebViewActivity";
argv[8] = "-e";
argv[9] = "w1.fi.wpadebug.URL";
argv[10] = (void *) url;
argv[11] = "--user";
argv[12] = "-3"; /* USER_CURRENT_OR_SELF */
argv[13] = NULL;
execv("/system/bin/am", argv);
wpa_printf(MSG_ERROR, "execv: %s", strerror(errno));
exit(0);
return -1;
}
eloop_register_timeout(300, 0, browser_timeout, &data, NULL);
eloop_run();
eloop_cancel_timeout(browser_timeout, &data, NULL);
http_server_deinit(http);
eloop_destroy();
wpa_printf(MSG_INFO, "Closing Android browser");
if (os_exec("/system/bin/am",
"start -a android.action.MAIN "
"-c android.intent.category.LAUNCHER "
"-n w1.fi.wpadebug/.WpaWebViewActivity "
"-e w1.fi.wpadebug.URL FINISH", 1) != 0) {
wpa_printf(MSG_INFO, "Failed to close wpadebug browser");
}
return data.success;
}
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;
int timeout = 30;
if (os_program_init())
return -1;
os_memset(&eapol_test, 0, sizeof(eapol_test));
eapol_test.connect_info = "CONNECT 11Mbps 802.11b";
os_memcpy(eapol_test.own_addr, "\x02\x00\x00\x00\x00\x01", ETH_ALEN);
wpa_debug_level = 0;
wpa_debug_show_keys = 1;
for (;;) {
c = getopt(argc, argv, "a:c:C:M:np:r:s:St:W");
if (c < 0)
break;
switch (c) {
case 'a':
as_addr = optarg;
break;
case 'c':
conf = optarg;
break;
case 'C':
eapol_test.connect_info = optarg;
break;
case 'M':
if (hwaddr_aton(optarg, eapol_test.own_addr)) {
usage();
return -1;
}
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 't':
timeout = atoi(optarg);
break;
case 'W':
wait_for_monitor++;
break;
default:
usage();
return -1;
}
}
if (argc > optind && os_strcmp(argv[optind], "scard") == 0) {
return scard_test();
}
if (argc > optind && os_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;
}
if (eap_peer_register_methods()) {
wpa_printf(MSG_ERROR, "Failed to register EAP methods");
return -1;
}
if (eloop_init(&wpa_s)) {
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
return -1;
}
os_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);
wpa_s.ctrl_iface = wpa_supplicant_ctrl_iface_init(&wpa_s);
if (wpa_s.ctrl_iface == NULL) {
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.ctrl_iface);
eloop_register_timeout(timeout, 0, eapol_test_timeout, &eapol_test,
NULL);
eloop_register_timeout(0, 0, send_eap_request_identity, &wpa_s, NULL);
eloop_register_signal_terminate(eapol_test_terminate, NULL);
eloop_register_signal_reconfig(eapol_test_terminate, NULL);
eloop_run();
if (eapol_test_compare_pmk(&eapol_test) == 0 ||
eapol_test.no_mppe_keys)
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);
eap_peer_unregister_methods();
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");
os_program_deinit();
return ret;
}
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 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 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;
}
int hs20_web_browser(const char *url)
{
struct http_server *http;
struct in_addr addr;
struct browser_data data;
pid_t pid;
wpa_printf(MSG_INFO, "Launching Android browser to %s", url);
os_memset(&data, 0, sizeof(data));
if (eloop_init() < 0) {
wpa_printf(MSG_ERROR, "eloop_init failed");
return -1;
}
addr.s_addr = htonl((127 << 24) | 1);
http = http_server_init(&addr, 12345, http_req, &data);
if (http == NULL) {
wpa_printf(MSG_ERROR, "http_server_init failed");
eloop_destroy();
return -1;
}
pid = fork();
if (pid < 0) {
wpa_printf(MSG_ERROR, "fork: %s", strerror(errno));
http_server_deinit(http);
eloop_destroy();
return -1;
}
if (pid == 0) {
/* run the external command in the child process */
char *argv[7];
argv[0] = "browser-android";
argv[1] = "start";
argv[2] = "-a";
argv[3] = "android.intent.action.VIEW";
argv[4] = "-d";
argv[5] = (void *) url;
argv[6] = NULL;
execv("/system/bin/am", argv);
wpa_printf(MSG_ERROR, "execv: %s", strerror(errno));
exit(0);
return -1;
}
eloop_register_timeout(30, 0, browser_timeout, &data, NULL);
eloop_run();
eloop_cancel_timeout(browser_timeout, &data, NULL);
http_server_deinit(http);
eloop_destroy();
wpa_printf(MSG_INFO, "Closing Android browser");
if (system("/system/bin/input keyevent KEYCODE_HOME") != 0) {
wpa_printf(MSG_INFO, "Failed to inject keyevent");
}
return data.success;
}
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 i = 0;
struct wpa_init_params params;
if (eloop_init())
{
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
return -1;
}
/* init socket client */
int sockfd = -1;
char buf[MAX_BUF_LEN];
int buf_size = 0;
struct sockaddr_in serveraddr;
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(PORT);
serveraddr.sin_addr.s_addr = inet_addr(IP_ADDR);
//bzero(&(serveraddr.sin_zero), 8);/* in string.h */
memset(&serveraddr.sin_zero, 0, 8);
sockfd = socket(PF_INET,SOCK_STREAM,0);
assert((sockfd != -1));
global_sockfd = sockfd;
int ret = connect(sockfd,(struct sockaddr *)&serveraddr,sizeof(struct sockaddr));
if(ret == -1)
{
fprintf(stderr,"Connect Error,%s:%d\n",__FILE__,__LINE__);
return -1;
}
if (eloop_register_read_sock(sockfd, handle_agent_read, hapd.bss, NULL))
{
printf("Could not register agent read socket\n");
return -1;
}
/* global init nl80211 */
for (i = 0; wpa_drivers[i]; i++)
{
if (wpa_drivers[i]->global_init)
{
global_priv = wpa_drivers[i]->global_init();
if (global_priv == NULL) {
printf("global_init Failed to initialize\n");
return -1;
}
}
}
/* agent request AP params */
buf_size = MAX_BUF_LEN;
ret = wiflow_pdu_format(buf,&buf_size,WIFLOW_INIT_PARAMS_REQUEST);
if(ret < 0 || buf_size <= 0)
{
fprintf(stderr,"wiflow_pdu_format Error,%s:%d\n",__FILE__,__LINE__);
}
ret = send(sockfd,buf,buf_size,0);
if(ret < 0)
{
fprintf(stderr,"send Error,%s:%d\n",__FILE__,__LINE__);
}
printf("NL80211 global initialized\n");
eloop_run();
return 0;
}
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;
#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[])
{
int i, j;
int c, res, ret = -1;
const char *global_wpa_s_ctrl_intf = NULL;
const char *wrapd_ctrl_intf = NULL;
const char *vma_conf_file = NULL;
const char *wpa_s_conf_file = NULL;
const char *add_psta_addr = NULL;
const char *remove_psta_addr = NULL;
int daemonize = 0;
int hostapd_num = 0;
int list_psta_addr = 0;
int do_mat = 0;
int do_isolation = 0;
int do_timer = 0;
int conn_cnt = 0;
int slave_mode = 0;
char msg[128] = {0};
if (os_program_init())
return -1;
for (i = 0; i < HOSTAPD_CNT; i ++) {
ap_ifname[i] = NULL;
wrapd_hostapd_conn[i] = NULL;
}
for (;;) {
c = getopt(argc, argv, "g:a:p:w:A:R:BLMSITc:v:d:h");
if (c < 0)
break;
switch (c) {
case 'g':
wrapd_ctrl_intf = optarg;
break;
case 'w':
global_wpa_s_ctrl_intf = optarg;
break;
case 'a':
if (hostapd_num >= HOSTAPD_CNT) {
usage();
goto out;
}
ap_ifname[hostapd_num ++] = os_strdup(optarg);
break;
case 'p':
mpsta_ifname = os_strdup(optarg);
break;
case 'd':
dbdc_ifname = os_strdup(optarg);
break;
case 'B':
daemonize++;
break;
case 'A':
add_psta_addr = optarg;
break;
case 'R':
remove_psta_addr = optarg;
break;
case 'L':
list_psta_addr = 1;
break;
case 'M':
do_mat = 1;
break;
case 'I':
do_isolation = 1;
break;
case 'S':
slave_mode = 1;
break;
case 'T':
do_timer = 1;
break;
case 'c':
wpa_s_conf_file = optarg;
break;
case 'v':
vma_conf_file = optarg;
break;
case 'h':
usage();
ret = 0;
goto out;
default:
usage();
goto out;
}
}
for (i = 0; i < hostapd_num - 1; i ++) {
for (j = i + 1; j < hostapd_num; j ++) {
if (os_strcmp(ap_ifname[i], ap_ifname[j]) == 0) {
wrapd_printf("duplicated ap_ifname[%d] of ap_ifname[%d]", i, j);
goto out;
}
}
}
if(NULL == wrapd_ctrl_intf)
wrapd_ctrl_intf = wrapd_ctrl_iface_path;
if (slave_mode) {
if(add_psta_addr) {
if (do_mat) {
if (dbdc_ifname) {
wrapd_printf("Invalid MAT option, DBDC is enabled");
goto out;
}
res = os_snprintf(msg, sizeof(msg),"ETH_PSTA_ADD MAT %s %s", ap_ifname[0], add_psta_addr);
} else
res = os_snprintf(msg, sizeof(msg),"ETH_PSTA_ADD %s %s", ap_ifname[0], add_psta_addr);
if (res < 0 || res >= sizeof(msg)){
wrapd_printf("Fail to build ETH_PSTA_ADD msg");
goto out;
}
wrapd_send_msg(msg, 128, wrapd_ctrl_intf);
ret = 0;
goto out;
} else if (remove_psta_addr) {
res = os_snprintf(msg, sizeof(msg),"ETH_PSTA_REMOVE %s", remove_psta_addr);
if (res < 0 || res >= sizeof(msg)){
wrapd_printf("Fail to build ETH_PSTA_REMOVE msg");
goto out;
}
wrapd_send_msg(msg, (16 + 17), wrapd_ctrl_intf);
ret = 0;
goto out;
} else if (list_psta_addr) {
wrapd_send_msg("PSTA_LIST", 9, wrapd_ctrl_intf);
ret = 0;
goto out;
}
}
if(NULL == global_wpa_s_ctrl_intf)
global_wpa_s_ctrl_intf = global_wpa_s_ctrl_iface_path;
if (eloop_init()) {
wrapd_printf("Failed to initialize event loop");
goto out;
}
wrapd_handle = wrapd_conn_to_global_wpa_s(global_wpa_s_ctrl_intf, wpa_s_conf_file, do_isolation, do_timer);
if (wrapd_handle == NULL)
goto out;
wrapd_conn = wrapd_ctrl_open(wrapd_ctrl_intf, wrapd_handle);
for (i = 0; i < HOSTAPD_CNT; i ++) {
if(ap_ifname[i]) {
for (conn_cnt = 0; conn_cnt < HOSTAPD_CONN_TIMES; conn_cnt ++) {
wrapd_hostapd_conn[i] = wrapd_conn_to_hostapd(ap_ifname[i]);
if (wrapd_hostapd_conn[i]) {
wrapd_printf("WRAP hostapd(%s) connected", ap_ifname[i]);
break;
}
os_sleep(1, 0);
}
if(wrapd_hostapd_conn[i]) {
if (wpa_ctrl_attach((struct wpa_ctrl *)wrapd_hostapd_conn[i]) != 0) {
wrapd_printf("Failed to attach to WRAP hostapd(%s)", ap_ifname[i]);;
goto out;
}
wrapd_printf("WRAP hostapd(%s) attached", ap_ifname[i]);
eloop_register_read_sock(wrapd_hostapd_conn[i]->sock, wrapd_hostapd_ctrl_iface_receive, wrapd_handle, (void *)ap_ifname[i]);
} else {
wrapd_printf("WRAP hostapd(%s) not exists", ap_ifname[i]);
}
}
}
if(mpsta_ifname == NULL) {
wrapd_printf("Failed to connect to MPSTA wpa_s - mpsta_ifname == NULL");
goto out;
}
for (conn_cnt = 0; conn_cnt < WPA_S_CONN_TIMES; conn_cnt ++) {
/*
* Delay to ensure scan doesn't overlap with ht40 intol acs scan, else will cause
* scan to fail and will take more time for MPSTA to associate.
* EV 131644
*/
if(conn_cnt == 0)
os_sleep(3, 0);
wrapd_wpa_s_conn = wrapd_conn_to_mpsta_wpa_s(mpsta_ifname);
if (wrapd_wpa_s_conn) {
wrapd_printf("MPSTA wpa_s(%s) connected", mpsta_ifname);
break;
}
os_sleep(1, 0);
}
if(wrapd_wpa_s_conn) {
if (wpa_ctrl_attach((struct wpa_ctrl *)wrapd_wpa_s_conn) != 0) {
wrapd_printf("Failed to attach to MPSTA wpa_s(%s)", mpsta_ifname);
goto out;
}
wrapd_printf("MPSTA wpa_s(%s) attached", mpsta_ifname);
eloop_register_read_sock(wrapd_wpa_s_conn->sock, wrapd_wpa_s_ctrl_iface_receive, wrapd_handle, NULL);
} else {
wrapd_printf("MPSTA wpa_s(%s) not exists", mpsta_ifname);
}
if (vma_conf_file) {
wrapd_load_vma_list(vma_conf_file, wrapd_handle);
}
if (daemonize && os_daemonize(NULL)) {
wrapd_printf("daemon");
goto out;
}
eloop_run();
out:
for (i = 0; i < HOSTAPD_CNT; i ++) {
if (ap_ifname[i])
os_free(ap_ifname[i]);
if (wrapd_hostapd_conn[i])
wpa_ctrl_close((struct wpa_ctrl *)wrapd_hostapd_conn[i]);
}
if (dbdc_ifname)
os_free(dbdc_ifname);
if (mpsta_ifname)
os_free(mpsta_ifname);
if (wrapd_wpa_s_conn)
wpa_ctrl_close((struct wpa_ctrl *)wrapd_wpa_s_conn);
os_program_deinit();
return ret;
}
int main(int argc, char *argv[])
{
int c;
const char *read_file = NULL;
const char *read_wired_file = NULL;
const char *write_file = NULL;
const char *ifname = NULL;
const char *ifname_wired = NULL;
struct wlantest wt;
int ctrl_iface = 0;
wpa_debug_level = MSG_INFO;
wpa_debug_show_keys = 1;
if (os_program_init())
return -1;
wlantest_init(&wt);
for (;;) {
c = getopt(argc, argv, "cdf:hi:I:p:P:qr:R:w:W:");
if (c < 0)
break;
switch (c) {
case 'c':
ctrl_iface = 1;
break;
case 'd':
if (wpa_debug_level > 0)
wpa_debug_level--;
break;
case 'f':
if (add_pmk_file(&wt, optarg) < 0)
return -1;
break;
case 'h':
usage();
return 0;
case 'i':
ifname = optarg;
break;
case 'I':
ifname_wired = optarg;
break;
case 'p':
add_passphrase(&wt, optarg);
break;
case 'P':
add_secret(&wt, optarg);
break;
case 'q':
wpa_debug_level++;
break;
case 'r':
read_file = optarg;
break;
case 'R':
read_wired_file = optarg;
break;
case 'w':
write_file = optarg;
break;
case 'W':
if (add_wep(&wt, optarg) < 0)
return -1;
break;
default:
usage();
return -1;
}
}
if (ifname == NULL && ifname_wired == NULL &&
read_file == NULL && read_wired_file == NULL) {
usage();
return 0;
}
if (eloop_init())
return -1;
if (write_file && write_pcap_init(&wt, write_file) < 0)
return -1;
if (read_wired_file && read_wired_cap_file(&wt, read_wired_file) < 0)
return -1;
if (read_file && read_cap_file(&wt, read_file) < 0)
return -1;
if (ifname && monitor_init(&wt, ifname) < 0)
return -1;
if (ifname_wired && monitor_init_wired(&wt, ifname_wired) < 0)
return -1;
if (ctrl_iface && ctrl_init(&wt) < 0)
return -1;
eloop_register_signal_terminate(wlantest_terminate, &wt);
eloop_run();
wpa_printf(MSG_INFO, "Processed: rx_mgmt=%u rx_ctrl=%u rx_data=%u "
"fcs_error=%u",
wt.rx_mgmt, wt.rx_ctrl, wt.rx_data, wt.fcs_error);
wlantest_deinit(&wt);
eloop_destroy();
os_program_deinit();
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;
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;
}
