static int radius_client_init_acct(struct radius_client_data *radius) { struct hostapd_radius_servers *conf = radius->conf; int ok = 0; radius_close_acct_sockets(radius); radius->acct_serv_sock = socket(PF_INET, SOCK_DGRAM, 0); if (radius->acct_serv_sock < 0) wpa_printf(MSG_INFO, "RADIUS: socket[PF_INET,SOCK_DGRAM]: %s", strerror(errno)); else { radius_client_disable_pmtu_discovery(radius->acct_serv_sock); ok++; } #ifdef CONFIG_IPV6 radius->acct_serv_sock6 = socket(PF_INET6, SOCK_DGRAM, 0); if (radius->acct_serv_sock6 < 0) wpa_printf(MSG_INFO, "RADIUS: socket[PF_INET6,SOCK_DGRAM]: %s", strerror(errno)); else ok++; #endif /* CONFIG_IPV6 */ if (ok == 0) return -1; radius_change_server(radius, conf->acct_server, NULL, radius->acct_serv_sock, radius->acct_serv_sock6, 0); if (radius->acct_serv_sock >= 0 && eloop_register_read_sock(radius->acct_serv_sock, radius_client_receive, radius, (void *) RADIUS_ACCT)) { wpa_printf(MSG_INFO, "RADIUS: Could not register read socket for accounting server"); radius_close_acct_sockets(radius); return -1; } #ifdef CONFIG_IPV6 if (radius->acct_serv_sock6 >= 0 && eloop_register_read_sock(radius->acct_serv_sock6, radius_client_receive, radius, (void *) RADIUS_ACCT)) { wpa_printf(MSG_INFO, "RADIUS: Could not register read socket for accounting server"); radius_close_acct_sockets(radius); return -1; } #endif /* CONFIG_IPV6 */ return 0; }
static int radius_client_init_auth(struct radius_client_data *radius) { struct hostapd_radius_servers *conf = radius->conf; int ok = 0; radius->auth_serv_sock = socket(PF_INET, SOCK_DGRAM, 0); if (radius->auth_serv_sock < 0) perror("socket[PF_INET,SOCK_DGRAM]"); else { radius_client_disable_pmtu_discovery(radius->auth_serv_sock); ok++; } #ifdef CONFIG_IPV6 radius->auth_serv_sock6 = socket(PF_INET6, SOCK_DGRAM, 0); if (radius->auth_serv_sock6 < 0) perror("socket[PF_INET6,SOCK_DGRAM]"); else ok++; #endif /* CONFIG_IPV6 */ if (ok == 0) return -1; radius_change_server(radius, conf->auth_server, NULL, radius->auth_serv_sock, radius->auth_serv_sock6, 1); if (radius->auth_serv_sock >= 0 && eloop_register_read_sock(radius->auth_serv_sock, radius_client_receive, radius, (void *) RADIUS_AUTH)) { printf("Could not register read socket for authentication " "server\n"); return -1; } #ifdef CONFIG_IPV6 if (radius->auth_serv_sock6 >= 0 && eloop_register_read_sock(radius->auth_serv_sock6, radius_client_receive, radius, (void *) RADIUS_AUTH)) { printf("Could not register read socket for authentication " "server\n"); return -1; } #endif /* CONFIG_IPV6 */ return 0; }
static int l2_packet_init_libpcap(struct l2_packet_data *l2, unsigned short protocol) { bpf_u_int32 pcap_maskp, pcap_netp; char pcap_filter[200], pcap_err[PCAP_ERRBUF_SIZE]; struct bpf_program pcap_fp; pcap_lookupnet(l2->ifname, &pcap_netp, &pcap_maskp, pcap_err); l2->pcap = pcap_open_live(l2->ifname, 2500, 0, 10, pcap_err); if (l2->pcap == NULL) { fprintf(stderr, "pcap_open_live: %s\n", pcap_err); fprintf(stderr, "ifname='%s'\n", l2->ifname); return -1; } if (pcap_datalink(l2->pcap) != DLT_EN10MB && pcap_set_datalink(l2->pcap, DLT_EN10MB) < 0) { fprintf(stderr, "pcap_set_datalink(DLT_EN10MB): %s\n", pcap_geterr(l2->pcap)); return -1; } os_snprintf(pcap_filter, sizeof(pcap_filter), "not ether src " MACSTR " and " "( ether dst " MACSTR " or ether dst " MACSTR " ) and " "ether proto 0x%x", MAC2STR(l2->own_addr), /* do not receive own packets */ MAC2STR(l2->own_addr), MAC2STR(pae_group_addr), protocol); if (pcap_compile(l2->pcap, &pcap_fp, pcap_filter, 1, pcap_netp) < 0) { fprintf(stderr, "pcap_compile: %s\n", pcap_geterr(l2->pcap)); return -1; } if (pcap_setfilter(l2->pcap, &pcap_fp) < 0) { fprintf(stderr, "pcap_setfilter: %s\n", pcap_geterr(l2->pcap)); return -1; } pcap_freecode(&pcap_fp); #ifndef __sun__ /* * When libpcap uses BPF we must enable "immediate mode" to * receive frames right away; otherwise the system may * buffer them for us. */ { unsigned int on = 1; if (ioctl(pcap_fileno(l2->pcap), BIOCIMMEDIATE, &on) < 0) { fprintf(stderr, "%s: cannot enable immediate mode on " "interface %s: %s\n", __func__, l2->ifname, strerror(errno)); /* XXX should we fail? */ } } #endif /* __sun__ */ eloop_register_read_sock(pcap_get_selectable_fd(l2->pcap), l2_packet_receive, l2, l2->pcap); return 0; }
struct l2_packet_data * l2_packet_init( const char *ifname, const u8 *own_addr, unsigned short protocol, void (*rx_callback)(void *ctx, const u8 *src_addr, const u8 *buf, size_t len), void *rx_callback_ctx, int l2_hdr) { struct l2_packet_data *l2; l2 = (struct l2_packet_data*)os_zalloc(sizeof(struct l2_packet_data)); if (l2 == NULL) return NULL; os_strlcpy(l2->ifname, ifname, sizeof(l2->ifname)); l2->rx_callback = rx_callback; l2->rx_callback_ctx = rx_callback_ctx; l2->l2_hdr = l2_hdr; /* * TODO: open connection for receiving frames */ l2->fd = -1; eloop_register_read_sock(l2->fd, l2_packet_receive, l2, NULL); return l2; }
struct netlink_data * netlink_init(struct netlink_config *cfg) { struct netlink_data *netlink; struct sockaddr_nl local; netlink = os_zalloc(sizeof(*netlink)); if (netlink == NULL) return NULL; netlink->cfg = cfg; netlink->sock = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (netlink->sock < 0) { wpa_printf(MSG_ERROR, "netlink: Failed to open netlink " "socket: %s", strerror(errno)); netlink_deinit(netlink); return NULL; } os_memset(&local, 0, sizeof(local)); local.nl_family = AF_NETLINK; local.nl_groups = RTMGRP_LINK; if (bind(netlink->sock, (struct sockaddr *) &local, sizeof(local)) < 0) { wpa_printf(MSG_ERROR, "netlink: Failed to bind netlink " "socket: %s", strerror(errno)); netlink_deinit(netlink); return NULL; } eloop_register_read_sock(netlink->sock, netlink_receive, netlink, NULL); return netlink; }
int32 WPASupplicantApp::_SupplicantThread(void *data) { WPASupplicantApp *app = (WPASupplicantApp *)data; // Register our notify socket with the polling event loop. if (eloop_register_read_sock(app->fNotifySockets[0], _EventLoopProcessEvents, app->fWPAGlobal, app) != 0) { return B_ERROR; } wpa_supplicant_run(app->fWPAGlobal); eloop_unregister_read_sock(app->fNotifySockets[0]); // There are two reasons why the supplicant thread quit: // 1. The event loop was terminated because of a signal or error and the // application is still there and running. // 2. The app has quit and stopped the event loop. // // In case of 2. we're done, but in case of 1. we need to quit the still // running application. We use the app messenger to reach the app if it is // still running. If it already quit the SendMessage() will simply fail. be_app_messenger.SendMessage(B_QUIT_REQUESTED); return B_OK; }
static int madwifi_wireless_event_init(void *priv) { struct madwifi_driver_data *drv = priv; int s; struct sockaddr_nl local; madwifi_get_we_version(drv); drv->wext_sock = -1; s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (s < 0) { perror("socket(PF_NETLINK,SOCK_RAW,NETLINK_ROUTE)"); return -1; } memset(&local, 0, sizeof(local)); local.nl_family = AF_NETLINK; local.nl_groups = RTMGRP_LINK; if (bind(s, (struct sockaddr *) &local, sizeof(local)) < 0) { perror("bind(netlink)"); close(s); return -1; } eloop_register_read_sock(s, madwifi_wireless_event_receive, drv, NULL); drv->wext_sock = s; return 0; }
int edit_init(void (*cmd_cb)(void *ctx, char *cmd), void (*eof_cb)(void *ctx), char ** (*completion_cb)(void *ctx, const char *cmd, int pos), void *ctx, const char *history_file, const char *ps) { edit_cb_ctx = ctx; edit_cmd_cb = cmd_cb; edit_eof_cb = eof_cb; edit_completion_cb = completion_cb; rl_attempted_completion_function = readline_completion; if (history_file) { read_history(history_file); stifle_history(100); } eloop_register_read_sock(STDIN_FILENO, edit_read_char, NULL, NULL); if (ps) { size_t blen = os_strlen(ps) + 3; char *ps2 = os_malloc(blen); if (ps2) { os_snprintf(ps2, blen, "%s> ", ps); rl_callback_handler_install(ps2, readline_cmd_handler); os_free(ps2); return 0; } } rl_callback_handler_install("> ", readline_cmd_handler); return 0; }
static int rtl871x_mgnt_sock_init(struct rtl871x_driver_data *drv, const char *name) { int sock; struct ifreq ifr; struct sockaddr_ll addr; sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); if (sock < 0) { perror("socket[PF_PACKET,SOCK_RAW]"); return -1; } if (eloop_register_read_sock(sock, rtl871x_recvive_mgmt_frame, drv->hapd, NULL)) { printf("Could not register read socket\n"); return -1; } memset(&ifr, 0, sizeof(ifr)); //snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%sap", drv->iface); os_strlcpy(ifr.ifr_name, name, sizeof(ifr.ifr_name)); if (ioctl(sock, SIOCGIFINDEX, &ifr) != 0) { perror("ioctl(SIOCGIFINDEX)"); return -1; } //if (rtl871x_set_iface_flags(drv, 1)) { // return -1; //} memset(&addr, 0, sizeof(addr)); addr.sll_family = AF_PACKET; addr.sll_ifindex = ifr.ifr_ifindex; wpa_printf(MSG_DEBUG, "Opening raw packet socket for ifindex %d", addr.sll_ifindex); if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { perror("bind"); return -1; } memset(&ifr, 0, sizeof(ifr)); os_strlcpy(ifr.ifr_name, name, sizeof(ifr.ifr_name)); if (ioctl(sock, SIOCGIFHWADDR, &ifr) != 0) { perror("ioctl(SIOCGIFHWADDR)"); return -1; } if (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) { printf("Invalid HW-addr family 0x%04x\n", ifr.ifr_hwaddr.sa_family); return -1; } //memcpy(drv->hapd->own_addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN); return sock; }
struct ctrl_iface_global_priv *wpa_supplicant_global_ctrl_iface_init(struct wpa_global *global) { struct ctrl_iface_global_priv *priv; struct sockaddr_in addr; int port = WPA_GLOBAL_CTRL_IFACE_PORT; priv = os_zalloc(sizeof(*priv)); if (priv == NULL) { return NULL; } priv->sock = -1; os_get_random(priv->cookie, COOKIE_LEN); if (global->params.ctrl_interface == NULL) { return priv; } wpa_printf(MSG_DEBUG, "Global control interface '%s'", global->params.ctrl_interface); /* WARNING: UDP is unreliable (indirectly selected by use of SOCK_DRAM), hence not suitable * for API interfaces. * - change to use TCP (SOCK_STREAM), for a reliable transport. */ priv->sock = socket(PF_INET, SOCK_DGRAM, 0); if (priv->sock < 0) { wpa_printf(MSG_ERROR, "socket(PF_INET): %s", strerror(errno)); goto fail; } os_memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE addr.sin_addr.s_addr = INADDR_ANY; #else /* CONFIG_CTRL_IFACE_UDP_REMOTE */ addr.sin_addr.s_addr = htonl((127 << 24) | 1); #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ try_again: addr.sin_port = htons(port); if (bind(priv->sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) { port++; if ((port - WPA_GLOBAL_CTRL_IFACE_PORT) < WPA_GLOBAL_CTRL_IFACE_PORT_LIMIT) { goto try_again; } wpa_printf(MSG_ERROR, "bind(AF_INET): %s", strerror(errno)); goto fail; } #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE wpa_printf(MSG_DEBUG, "global_ctrl_iface_init UDP port: %d", port); #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ eloop_register_read_sock(priv->sock, wpa_supplicant_global_ctrl_iface_receive, global, priv); return priv; fail: if (priv->sock >= 0) { close(priv->sock); } os_free(priv); return NULL; }
int wsc_ie_init(struct hostapd_data *hapd) { struct sockaddr_in to; char sendBuf[5]; wpa_printf(MSG_DEBUG, "WSC_IE: In wsc_ie_init"); g_wsc_ie_data = malloc(sizeof(WSC_IE_DATA)); if (g_wsc_ie_data == NULL) { return -1; } memset(g_wsc_ie_data, 0, sizeof(WSC_IE_DATA)); g_wsc_ie_data->hapd = hapd; g_wsc_ie_data->udpFdCom = udp_open(); eloop_register_read_sock(g_wsc_ie_data->udpFdCom, wsc_ie_read_callback, g_wsc_ie_data, NULL); /* Send a start packet */ strcpy(sendBuf, "PORT"); to.sin_addr.s_addr = inet_addr(WSC_WLAN_UDP_ADDR); to.sin_family = AF_INET; to.sin_port = htons(WSC_WLAN_UDP_PORT); if (udp_write(g_wsc_ie_data->udpFdCom, sendBuf, 5, &to) < 5) { wpa_printf(MSG_ERROR, "WSC_IE: Sending Port message to " "upper Layer failed"); return -1; } else { wpa_printf(MSG_DEBUG, "WSC_IE: send port = %d", WSC_WLAN_UDP_PORT ); } return 0; }
int wpa_driver_register_event_cb(struct wpa_driver_ndis_data *drv) { struct sockaddr_in addr; drv->event_sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->event_sock < 0) { perror("socket"); return -1; } /* These events are received from an external program, ndis_events, * which is converting WMI events to more "UNIX-like" input for * wpa_supplicant, i.e., UDP packets that can be received through the * eloop mechanism. */ memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = htonl((127 << 24) | 1); addr.sin_port = htons(9876); if (bind(drv->event_sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { perror("bind"); close(drv->event_sock); drv->event_sock = -1; return -1; } eloop_register_read_sock(drv->event_sock, wpa_driver_ndis_event_cb, drv, NULL); return 0; }
struct wpas_binder_priv *wpas_binder_init(struct wpa_global *global) { struct wpas_binder_priv *priv; wpa_supplicant_binder::BinderManager *binder_manager; priv = (wpas_binder_priv *)os_zalloc(sizeof(*priv)); if (!priv) return NULL; priv->global = global; android::ProcessState::self()->setThreadPoolMaxThreadCount(0); android::IPCThreadState::self()->disableBackgroundScheduling(true); android::IPCThreadState::self()->setupPolling(&priv->binder_fd); wpa_printf(MSG_INFO, "Process binder events on FD %d", priv->binder_fd); if (priv->binder_fd < 0) goto err; /* Look for read events from the binder socket in the eloop. */ if (eloop_register_read_sock( priv->binder_fd, wpas_binder_sock_handler, global, priv) < 0) goto err; binder_manager = wpa_supplicant_binder::BinderManager::getInstance(); if (!binder_manager) goto err; binder_manager->registerBinderService(global); /* We may not need to store this binder manager reference in the * global data strucure because we've made it a singleton class. */ priv->binder_manager = (void *)binder_manager; return priv; err: wpas_binder_deinit(priv); return NULL; }
static void ctrl_connect(int sock, void *eloop_ctx, void *sock_ctx) { struct wlantest *wt = eloop_ctx; int conn, i; conn = accept(sock, NULL, NULL); if (conn < 0) { wpa_printf(MSG_INFO, "accept(ctrl): %s", strerror(errno)); return; } wpa_printf(MSG_MSGDUMP, "New control interface connection %d", conn); for (i = 0; i < MAX_CTRL_CONNECTIONS; i++) { if (wt->ctrl_socks[i] < 0) break; } if (i == MAX_CTRL_CONNECTIONS) { wpa_printf(MSG_INFO, "No room for new control connection"); close(conn); return; } wt->ctrl_socks[i] = conn; eloop_register_read_sock(conn, ctrl_read, wt, NULL); }
struct ctrl_iface_global_priv * wpa_supplicant_global_ctrl_iface_init(struct wpa_global *global) { struct ctrl_iface_global_priv *priv; struct sockaddr_in addr; int port = WPA_GLOBAL_CTRL_IFACE_PORT; priv = os_zalloc(sizeof(*priv)); if (priv == NULL) return NULL; priv->sock = -1; os_get_random(priv->cookie, COOKIE_LEN); if (global->params.ctrl_interface == NULL) return priv; wpa_printf(MSG_DEBUG, "Global control interface '%s'", global->params.ctrl_interface); priv->sock = socket(PF_INET, SOCK_DGRAM, 0); if (priv->sock < 0) { perror("socket(PF_INET)"); goto fail; } os_memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE addr.sin_addr.s_addr = INADDR_ANY; #else /* CONFIG_CTRL_IFACE_UDP_REMOTE */ addr.sin_addr.s_addr = htonl((127 << 24) | 1); #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ try_again: addr.sin_port = htons(port); if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { port++; if ((port - WPA_GLOBAL_CTRL_IFACE_PORT) < WPA_GLOBAL_CTRL_IFACE_PORT_LIMIT) goto try_again; perror("bind(AF_INET)"); goto fail; } #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE wpa_printf(MSG_DEBUG, "global_ctrl_iface_init UDP port: %d", port); #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ eloop_register_read_sock(priv->sock, wpa_supplicant_global_ctrl_iface_receive, global, priv); return priv; fail: if (priv->sock >= 0) close(priv->sock); os_free(priv); return NULL; }
void * wpa_driver_wext_init(void *ctx, const char *ifname) { int s, flags; struct sockaddr_nl local; struct wpa_driver_wext_data *drv; drv = malloc(sizeof(*drv)); if (drv == NULL) return NULL; memset(drv, 0, sizeof(*drv)); drv->ctx = ctx; strncpy(drv->ifname, ifname, sizeof(drv->ifname)); drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->ioctl_sock < 0) { perror("socket(PF_INET,SOCK_DGRAM)"); free(drv); return NULL; } s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (s < 0) { perror("socket(PF_NETLINK,SOCK_RAW,NETLINK_ROUTE)"); close(drv->ioctl_sock); free(drv); return NULL; } memset(&local, 0, sizeof(local)); local.nl_family = AF_NETLINK; local.nl_groups = RTMGRP_LINK; if (bind(s, (struct sockaddr *) &local, sizeof(local)) < 0) { perror("bind(netlink)"); close(s); close(drv->ioctl_sock); free(drv); return NULL; } eloop_register_read_sock(s, wpa_driver_wext_event_receive, drv, ctx); drv->event_sock = s; /* * Make sure that the driver does not have any obsolete PMKID entries. */ wpa_driver_wext_flush_pmkid(drv); if (wpa_driver_wext_set_mode(drv, 0) < 0) { printf("Could not configure driver to use managed mode\n"); } if (wpa_driver_wext_get_ifflags(drv, &flags) != 0 || wpa_driver_wext_set_ifflags(drv, flags | IFF_UP) != 0) { printf("Could not set interface '%s' UP\n", drv->ifname); } return drv; }
struct l2_packet_data * l2_packet_init( const char *ifname, const u8 *own_addr, unsigned short protocol, void (*rx_callback)(void *ctx, const u8 *src_addr, const u8 *buf, size_t len), void *rx_callback_ctx, int l2_hdr) { struct l2_packet_data *l2; struct ifreq ifr; struct sockaddr_ll ll; l2 = os_zalloc(sizeof(struct l2_packet_data)); if (l2 == NULL) return NULL; os_strlcpy(l2->ifname, ifname, sizeof(l2->ifname)); l2->rx_callback = rx_callback; l2->rx_callback_ctx = rx_callback_ctx; l2->l2_hdr = l2_hdr; l2->fd = socket(PF_PACKET, l2_hdr ? SOCK_RAW : SOCK_DGRAM, htons(protocol)); if (l2->fd < 0) { perror("socket(PF_PACKET)"); os_free(l2); return NULL; } os_memset(&ifr, 0, sizeof(ifr)); os_strlcpy(ifr.ifr_name, l2->ifname, sizeof(ifr.ifr_name)); if (ioctl(l2->fd, SIOCGIFINDEX, &ifr) < 0) { perror("ioctl[SIOCGIFINDEX]"); close(l2->fd); os_free(l2); return NULL; } l2->ifindex = ifr.ifr_ifindex; os_memset(&ll, 0, sizeof(ll)); ll.sll_family = PF_PACKET; ll.sll_ifindex = ifr.ifr_ifindex; ll.sll_protocol = htons(protocol); if (bind(l2->fd, (struct sockaddr *) &ll, sizeof(ll)) < 0) { perror("bind[PF_PACKET]"); close(l2->fd); os_free(l2); return NULL; } if (ioctl(l2->fd, SIOCGIFHWADDR, &ifr) < 0) { perror("ioctl[SIOCGIFHWADDR]"); close(l2->fd); os_free(l2); return NULL; } os_memcpy(l2->own_addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN); eloop_register_read_sock(l2->fd, l2_packet_receive, l2, NULL); return l2; }
static void * wpa_driver_broadcom_init(void *ctx, const char *ifname) { int s; struct sockaddr_ll ll; struct wpa_driver_broadcom_data *drv; struct ifreq ifr; /* open socket to kernel */ if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { perror("socket"); return NULL; } /* do it */ os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ); if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) { perror(ifr.ifr_name); return NULL; } drv = os_zalloc(sizeof(*drv)); if (drv == NULL) return NULL; drv->ctx = ctx; os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname)); drv->ioctl_sock = s; s = socket(PF_PACKET, SOCK_RAW, ntohs(ETH_P_802_2)); if (s < 0) { perror("socket(PF_PACKET, SOCK_RAW, ntohs(ETH_P_802_2))"); close(drv->ioctl_sock); os_free(drv); return NULL; } os_memset(&ll, 0, sizeof(ll)); ll.sll_family = AF_PACKET; ll.sll_protocol = ntohs(ETH_P_802_2); ll.sll_ifindex = ifr.ifr_ifindex; ll.sll_hatype = 0; ll.sll_pkttype = PACKET_HOST; ll.sll_halen = 0; if (bind(s, (struct sockaddr *) &ll, sizeof(ll)) < 0) { perror("bind(netlink)"); close(s); close(drv->ioctl_sock); os_free(drv); return NULL; } eloop_register_read_sock(s, wpa_driver_broadcom_event_receive, ctx, NULL); drv->event_sock = s; wpa_driver_broadcom_set_wpa(drv, 1); return drv; }
static int wpa_driver_awext_open_mlme(struct wpa_driver_awext_data *drv) { int flags, ifindex, s, *i; struct sockaddr_ll addr; struct iwreq iwr; os_memset(&iwr, 0, sizeof(iwr)); os_strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); i = (int *) iwr.u.name; *i++ = PRISM2_PARAM_USER_SPACE_MLME; *i++ = 1; if (ioctl(drv->ioctl_sock, PRISM2_IOCTL_PRISM2_PARAM, &iwr) < 0) { wpa_printf(MSG_ERROR, "WEXT: Failed to configure driver to " "use user space MLME"); return -1; } ifindex = if_nametoindex(drv->wext->mlmedev); if (ifindex == 0) { wpa_printf(MSG_ERROR, "WEXT: mlmedev='%s' not found", drv->mlmedev); return -1; } if (wpa_driver_awext_get_ifflags_ifname(drv, drv->wext->mlmedev, &flags) != 0 || wpa_driver_awext_set_ifflags_ifname(drv, drv->wext->mlmedev, flags | IFF_UP) != 0) { wpa_printf(MSG_ERROR, "WEXT: Could not set interface " "'%s' UP", drv->mlmedev); return -1; } s = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); if (s < 0) { perror("socket[PF_PACKET,SOCK_RAW]"); return -1; } os_memset(&addr, 0, sizeof(addr)); addr.sll_family = AF_PACKET; addr.sll_ifindex = ifindex; if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { perror("bind(MLME)"); return -1; } if (eloop_register_read_sock(s, wpa_driver_awext_mlme_read, drv, NULL)) { wpa_printf(MSG_ERROR, "WEXT: Could not register MLME read " "socket"); close(s); return -1; } return s; }
int hostapd_init_sockets(struct hostap_driver_data *drv) { struct hostapd_data *hapd = drv->hapd; struct ifreq ifr; struct sockaddr_ll addr; drv->sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); if (drv->sock < 0) { perror("socket[PF_PACKET,SOCK_RAW]"); return -1; } if (eloop_register_read_sock(drv->sock, handle_read, drv->hapd, NULL)) { printf("Could not register read socket\n"); return -1; } memset(&ifr, 0, sizeof(ifr)); snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%sap", drv->iface); if (ioctl(drv->sock, SIOCGIFINDEX, &ifr) != 0) { perror("ioctl(SIOCGIFINDEX)"); return -1; } if (hostapd_set_iface_flags(drv, 1)) { return -1; } memset(&addr, 0, sizeof(addr)); addr.sll_family = AF_PACKET; addr.sll_ifindex = ifr.ifr_ifindex; HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "Opening raw packet socket for ifindex %d\n", addr.sll_ifindex); if (bind(drv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { perror("bind"); return -1; } memset(&ifr, 0, sizeof(ifr)); snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", drv->iface); if (ioctl(drv->sock, SIOCGIFHWADDR, &ifr) != 0) { perror("ioctl(SIOCGIFHWADDR)"); return -1; } if (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) { printf("Invalid HW-addr family 0x%04x\n", ifr.ifr_hwaddr.sa_family); return -1; } memcpy(drv->hapd->own_addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN); return 0; }
struct ctrl_iface_priv * wpa_supplicant_ctrl_iface_init(struct wpa_supplicant *wpa_s) { struct ctrl_iface_priv *priv; struct sockaddr_in addr; int port = WPA_CTRL_IFACE_PORT; priv = os_zalloc(sizeof(*priv)); if (priv == NULL) return NULL; priv->wpa_s = wpa_s; priv->sock = -1; os_get_random(priv->cookie, COOKIE_LEN); if (wpa_s->conf->ctrl_interface == NULL) return priv; priv->sock = socket(PF_INET, SOCK_DGRAM, 0); if (priv->sock < 0) { perror("socket(PF_INET)"); goto fail; } os_memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE addr.sin_addr.s_addr = INADDR_ANY; #else /* CONFIG_CTRL_IFACE_UDP_REMOTE */ addr.sin_addr.s_addr = htonl((127 << 24) | 1); #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ try_again: addr.sin_port = htons(port); if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { port--; if ((WPA_CTRL_IFACE_PORT - port) < WPA_CTRL_IFACE_PORT_LIMIT) goto try_again; perror("bind(AF_INET)"); goto fail; } #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE wpa_msg(wpa_s, MSG_DEBUG, "ctrl_iface_init UDP port: %d", port); #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ eloop_register_read_sock(priv->sock, wpa_supplicant_ctrl_iface_receive, wpa_s, priv); wpa_msg_register_cb(wpa_supplicant_ctrl_iface_msg_cb); return priv; fail: if (priv->sock >= 0) close(priv->sock); os_free(priv); return NULL; }
struct wrapd_ctrl * wrapd_ctrl_open(const char *ctrl_iface, wrapd_hdl_t *handle) { struct wrapd_ctrl *priv; struct sockaddr_un addr; if (ctrl_iface == NULL) return NULL; priv = os_zalloc(sizeof(*priv)); if (priv == NULL) return NULL; priv->sock = -1; priv->sock = socket(PF_UNIX, SOCK_DGRAM, 0); if (priv->sock < 0) { wrapd_printf("Fail to create socket"); goto fail; } os_memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; os_strlcpy(addr.sun_path, ctrl_iface, sizeof(addr.sun_path)); if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { wrapd_printf("1st, fail to bind socket"); if (connect(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { if (unlink(ctrl_iface) < 0) { wrapd_printf("Intf exists but does not allow to connect"); goto fail; } if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { wrapd_printf("2st, fail to bind socket"); goto fail; } wrapd_printf("2st, success to bind socket"); } else { wrapd_printf("Intf exists"); goto fail; } } eloop_register_read_sock(priv->sock, wrapd_ctrl_iface_receive, handle, NULL); return priv; fail: if (priv->sock >= 0) close(priv->sock); os_free(priv); return NULL; }
static void * bsd_init(struct hostapd_data *hapd, struct wpa_init_params *params) { struct bsd_driver_data *drv; drv = os_zalloc(sizeof(struct bsd_driver_data)); if (drv == NULL) { printf("Could not allocate memory for bsd driver data\n"); goto bad; } drv->hapd = hapd; drv->sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->sock < 0) { perror("socket[PF_INET,SOCK_DGRAM]"); goto bad; } os_strlcpy(drv->ifname, params->ifname, sizeof(drv->ifname)); drv->sock_xmit = l2_packet_init(drv->ifname, NULL, ETH_P_EAPOL, handle_read, drv, 0); if (drv->sock_xmit == NULL) goto bad; if (l2_packet_get_own_addr(drv->sock_xmit, params->own_addr)) goto bad; /* mark down during setup */ if (bsd_ctrl_iface(drv, 0) < 0) goto bad; drv->route = socket(PF_ROUTE, SOCK_RAW, 0); if (drv->route < 0) { perror("socket(PF_ROUTE,SOCK_RAW)"); goto bad; } eloop_register_read_sock(drv->route, bsd_wireless_event_receive, drv, NULL); if (bsd_set_mediaopt(drv, IFM_OMASK, IFM_IEEE80211_HOSTAP) < 0) { wpa_printf(MSG_ERROR, "%s: failed to set operation mode", __func__); goto bad; } return drv; bad: if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); if (drv->sock >= 0) close(drv->sock); if (drv != NULL) os_free(drv); return NULL; }
static void register_event_handler(struct wpa_ctrl *ctrl) { if (!ctrl_conn) return; if (interactive) { event_handler_registered = !eloop_register_read_sock(wpa_ctrl_get_fd(ctrl), hostapd_cli_receive, NULL, NULL); } }
static int eap_sim_db_open_socket(struct eap_sim_db_data *data) { struct sockaddr_un addr; static int counter = 0; if (os_strncmp(data->fname, "unix:", 5) != 0) return -1; data->sock = socket(PF_UNIX, SOCK_DGRAM, 0); if (data->sock < 0) { wpa_printf(MSG_INFO, "socket(eap_sim_db): %s", strerror(errno)); return -1; } os_memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; os_snprintf(addr.sun_path, sizeof(addr.sun_path), "/tmp/eap_sim_db_%d-%d", getpid(), counter++); os_free(data->local_sock); data->local_sock = os_strdup(addr.sun_path); if (data->local_sock == NULL) { close(data->sock); data->sock = -1; return -1; } if (bind(data->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { wpa_printf(MSG_INFO, "bind(eap_sim_db): %s", strerror(errno)); close(data->sock); data->sock = -1; return -1; } os_memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; os_strlcpy(addr.sun_path, data->fname + 5, sizeof(addr.sun_path)); if (connect(data->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { wpa_printf(MSG_INFO, "connect(eap_sim_db): %s", strerror(errno)); wpa_hexdump_ascii(MSG_INFO, "HLR/AuC GW socket", (u8 *) addr.sun_path, os_strlen(addr.sun_path)); close(data->sock); data->sock = -1; unlink(data->local_sock); os_free(data->local_sock); data->local_sock = NULL; return -1; } eloop_register_read_sock(data->sock, eap_sim_db_receive, data, NULL); return 0; }
struct radius_server_data * radius_server_init(struct radius_server_conf *conf) { struct radius_server_data *data; #ifndef CONFIG_IPV6 if (conf->ipv6) { fprintf(stderr, "RADIUS server compiled without IPv6 " "support.\n"); return NULL; } #endif /* CONFIG_IPV6 */ data = wpa_zalloc(sizeof(*data)); if (data == NULL) return NULL; os_get_time(&data->start_time); data->hostapd_conf = conf->hostapd_conf; data->eap_sim_db_priv = conf->eap_sim_db_priv; data->ssl_ctx = conf->ssl_ctx; data->ipv6 = conf->ipv6; data->clients = radius_server_read_clients(conf->client_file, conf->ipv6); if (data->clients == NULL) { printf("No RADIUS clients configured.\n"); radius_server_deinit(data); return NULL; } #ifdef CONFIG_IPV6 if (conf->ipv6) data->auth_sock = radius_server_open_socket6(conf->auth_port); else #endif /* CONFIG_IPV6 */ data->auth_sock = radius_server_open_socket(conf->auth_port); if (data->auth_sock < 0) { printf("Failed to open UDP socket for RADIUS authentication " "server\n"); radius_server_deinit(data); return NULL; } if (eloop_register_read_sock(data->auth_sock, radius_server_receive_auth, data, NULL)) { radius_server_deinit(data); return NULL; } return data; }
static int radius_client_init_acct(struct radius_client_data *radius) { struct hostapd_radius_servers *conf = radius->conf; int ok = 0; radius->acct_serv_sock = socket(PF_INET, SOCK_DGRAM, 0); if (radius->acct_serv_sock < 0) perror("socket[PF_INET,SOCK_DGRAM]"); else ok++; radius_change_server(radius, conf->acct_server, NULL, radius->acct_serv_sock, radius->acct_serv_sock6, 0); if (radius->acct_serv_sock >= 0 && eloop_register_read_sock(radius->acct_serv_sock, radius_client_receive, radius, (void *) RADIUS_ACCT)) { wpa_printf(MSG_ERROR, "Could not register read socket for accounting " "server\n"); return -1; } #ifdef CONFIG_IPV6 if (radius->acct_serv_sock6 >= 0 && eloop_register_read_sock(radius->acct_serv_sock6, radius_client_receive, radius, (void *) RADIUS_ACCT)) { wpa_printf(MSG_ERROR, "Could not register read socket for accounting " "server\n"); return -1; } #endif /* CONFIG_IPV6 */ return 0; }
int start_ipc(void *hapd,unsigned char *ssid_p, int *ssid_len_p,void *inject_func, char *cap_info){ memcpy( wlan0_capa, cap_info, 21); ReadConfiguration(&con_wtp); int sockfd = open_socket(); goto_preconnect(sockfd, hapd); wait_ADD_WLAN(sockfd, ssid_p, ssid_len_p, hapd); wl.frag = -1; wl.rts = -1; wl.freq_params.channel = 0; wl.freq_params.ht_enabled = 0; wl.freq_params.mode = 0; wl.freq_params.sec_channel_offset = 0; wl.freq_params.freq = 2452; wl.que[0].queue_id = 0; wl.que[0].cwmin = 3; wl.que[0].cwmax = 7; wl.que[0].aifs = 2; wl.que[1].queue_id = 1; wl.que[1].cwmin = 7; wl.que[1].cwmax = 15; wl.que[1].aifs = 2; wl.que[2].queue_id = 2; wl.que[2].cwmin = 15; wl.que[2].cwmax = 1023; wl.que[2].aifs = 3; wl.que[3].queue_id = 3; wl.que[3].cwmin = 31; wl.que[3].cwmax = 1023; wl.que[3].aifs = 7; //void (*pointer_WTP_inject_frame_in_air)(void*,unsigned char*,int); //pointer_WTP_inject_frame_in_air = inject_func; if(sockfd){ if (eloop_register_read_sock(sockfd, recv_request, hapd, inject_func)) { wpa_printf(MSG_ERROR, "Clould not register IPC socket start_ipc"); return 0; } } wpa_printf(MSG_DEBUG, "SOCKET Created %d",sockfd); return sockfd; }
int edit_init(void (*cmd_cb)(void *ctx, char *cmd), void (*eof_cb)(void *ctx), char ** (*completion_cb)(void *ctx, const char *cmd, int pos), void *ctx, const char *history_file) { edit_cb_ctx = ctx; edit_cmd_cb = cmd_cb; edit_eof_cb = eof_cb; eloop_register_read_sock(STDIN_FILENO, edit_read_char, NULL, NULL); printf("> "); fflush(stdout); return 0; }
static struct full_dynamic_vlan * full_dynamic_vlan_init(struct hostapd_data *hapd) { struct sockaddr_nl local; struct full_dynamic_vlan *priv; priv = os_zalloc(sizeof(*priv)); if (priv == NULL) return NULL; #ifndef CONFIG_VLAN_NETLINK vlan_set_name_type(hapd->conf->ssid.vlan_naming == DYNAMIC_VLAN_NAMING_WITH_DEVICE ? VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD : VLAN_NAME_TYPE_PLUS_VID_NO_PAD); #endif /* CONFIG_VLAN_NETLINK */ priv->s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (priv->s < 0) { wpa_printf(MSG_ERROR, "VLAN: %s: socket(PF_NETLINK,SOCK_RAW," "NETLINK_ROUTE) failed: %s", __func__, strerror(errno)); os_free(priv); return NULL; } os_memset(&local, 0, sizeof(local)); local.nl_family = AF_NETLINK; local.nl_groups = RTMGRP_LINK; if (bind(priv->s, (struct sockaddr *) &local, sizeof(local)) < 0) { wpa_printf(MSG_ERROR, "VLAN: %s: bind(netlink) failed: %s", __func__, strerror(errno)); close(priv->s); os_free(priv); return NULL; } if (eloop_register_read_sock(priv->s, vlan_event_receive, hapd, NULL)) { close(priv->s); os_free(priv); return NULL; } return priv; }