// This cgi uses the routines above to connect to a specific access point with the // given ESSID using the given password. int ICACHE_FLASH_ATTR cgiWiFiConnect(HttpdConnData *connData) { char essid[128]; char passwd[128]; if (connData->conn==NULL) return HTTPD_CGI_DONE; int el = httpdFindArg(connData->getArgs, "essid", essid, sizeof(essid)); int pl = httpdFindArg(connData->getArgs, "passwd", passwd, sizeof(passwd)); if (el > 0 && pl >= 0) { //Set to 0 if you want to disable the actual reconnecting bit os_strncpy((char*)stconf.ssid, essid, 32); os_strncpy((char*)stconf.password, passwd, 64); DBG("Wifi try to connect to AP %s pw %s\n", essid, passwd); //Schedule disconnect/connect os_timer_disarm(&reassTimer); os_timer_setfn(&reassTimer, reassTimerCb, NULL); os_timer_arm(&reassTimer, 1000, 0); // 1 second for the response of this request to make it jsonHeader(connData, 200); } else { jsonHeader(connData, 400); httpdSend(connData, "Cannot parse ssid or password", -1); } return HTTPD_CGI_DONE; }
uint8 ICACHE_FLASH_ATTR otb_conf_store_sta_conf(char *ssid, char *password, bool commit) { uint8 rc = OTB_CONF_RC_NOT_CHANGED; otb_conf_struct *conf = &otb_conf_private; bool update_rc; DEBUG("CONF: otb_conf_store_sta_conf entry"); if (os_strncmp(conf->ssid, ssid, OTB_CONF_WIFI_SSID_MAX_LEN) || os_strncmp(conf->password, password, OTB_CONF_WIFI_PASSWORD_MAX_LEN)) { INFO("CONF: New config: ssid, password"); rc = OTB_CONF_RC_CHANGED; os_strncpy(conf->ssid, ssid, OTB_CONF_WIFI_SSID_MAX_LEN); os_strncpy(conf->password, password, OTB_CONF_WIFI_PASSWORD_MAX_LEN); if (commit) { INFO("CONF: Committing new config: ssid, password"); update_rc = otb_conf_update(conf); if (!update_rc) { ERROR("CONF: Failed to update config"); rc = OTB_CONF_RC_ERROR; } } } DEBUG("CONF: otb_conf_store_sta_conf exit"); return rc; }
void restoreFactorySettings() { wifi_station_disconnect(); wifi_set_opmode(0x3); //reset to STA+AP mode struct softap_config apConfig; wifi_softap_get_config(&apConfig); os_strncpy((char*)apConfig.ssid, "smartswitch", 18); apConfig.authmode = 0; //Disable security wifi_softap_set_config(&apConfig); struct station_config stconf; os_strncpy((char*)stconf.ssid, "", 2); os_strncpy((char*)stconf.password, "", 2); wifi_station_set_config(&stconf); OLED_CLS(); OLED_Print(2, 0, "RESET", 1); os_printf("Reset completed. Restarting system...\n"); ioOutput(0, GPIO_OUTPUT1); ioOutput(0, GPIO_OUTPUT2); while (!GPIO_INPUT_GET(GPIO_BUTTON1)) { os_printf("."); }; while (!GPIO_INPUT_GET(GPIO_BUTTON2)) { os_printf("."); }; system_restart(); }
//This cgi uses the routines above to connect to a specific access point with the //given ESSID using the given password. int ICACHE_FLASH_ATTR cgiWiFiConnect(HttpdConnData *connData) { char essid[128]; char passwd[128]; static ETSTimer reassTimer; if (connData->conn==NULL) { //Connection aborted. Clean up. return HTTPD_CGI_DONE; } httpdFindArg(connData->postBuff, "essid", essid, sizeof(essid)); httpdFindArg(connData->postBuff, "passwd", passwd, sizeof(passwd)); os_strncpy((char*)stconf.ssid, essid, 32); os_strncpy((char*)stconf.password, passwd, 64); //Schedule disconnect/connect os_timer_disarm(&reassTimer); os_timer_setfn(&reassTimer, reassTimerCb, NULL); #if 0 os_timer_arm(&reassTimer, 1000, 0); httpdRedirect(connData, "connecting.html"); #else httpdRedirect(connData, "/wifi"); #endif return HTTPD_CGI_DONE; }
//This cgi uses the routines above to connect to a specific access point with the //given ESSID using the given password. int ICACHE_FLASH_ATTR cgiWiFiConnect(HttpdConnData *connData) { char essid[128]; char passwd[128]; static ETSTimer reassTimer; if (connData->conn==NULL) { //Connection aborted. Clean up. return HTTPD_CGI_DONE; } httpdFindArg(connData->post->buff, "essid", essid, sizeof(essid)); httpdFindArg(connData->post->buff, "passwd", passwd, sizeof(passwd)); os_strncpy((char*)stconf.ssid, essid, 32); os_strncpy((char*)stconf.password, passwd, 64); os_printf("Try to connect to AP %s pw %s\n", essid, passwd); //Schedule disconnect/connect os_timer_disarm(&reassTimer); os_timer_setfn(&reassTimer, reassTimerCb, NULL); //Set to 0 if you want to disable the actual reconnecting bit #ifdef DEMO_MODE httpdRedirect(connData, "/wifi"); #else os_timer_arm(&reassTimer, 500, 0); httpdRedirect(connData, "connecting.html"); #endif return HTTPD_CGI_DONE; }
void user_init(void) { char * ap = "SKUNKWILLEM"; char * pass = "******"; uart_init(BIT_RATE_115200, uart_receive, false); system_set_os_print(1); os_printf("\nUart init done... \n"); wifi_softap_get_config(&apconf); memset(apconf.ssid, 0, 32); memset(apconf.password, 0, 64); os_strncpy((char*)apconf.ssid, ap, 32); os_strncpy((char*)apconf.password, pass, 64); apconf.authmode = AUTH_WPA_WPA2_PSK; apconf.max_connection = 5; apconf.ssid_hidden = 0; wifi_softap_set_config(&apconf); IP4_ADDR(&IpInfo.gw, 192, 168, 10, 1); IP4_ADDR(&IpInfo.ip, 192, 168, 10, 1); IP4_ADDR(&IpInfo.netmask, 255, 255, 255, 0); wifi_softap_dhcps_stop(); dhcps_start(&IpInfo); wifi_set_ip_info(0x01, &IpInfo); os_timer_disarm(&waitTimer); os_timer_setfn(&waitTimer, init_udp, NULL); os_timer_arm(&waitTimer, 2000, 0); }
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_strncpy(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_strncpy(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; return drv; }
// Password authentication for admin interface int myPassFn(HttpdConnData *connData, int no, char *user, int userLen, char *pass, int passLen) { if(no==0) { os_strncpy(user, configGet()->admin_user, userLen); os_strncpy(pass, configGet()->admin_pass, passLen); return 1; } return 0; }
IROM void Flash::get(char* value, int length, const char* key, const char* dflt) { int idx=findKey(key); uint16_t len=4; if ( idx>=0 ) { if ( !loadItem(idx+1,(uint8_t*)value,len) ) { os_strncpy(value,dflt,length); } else { value[len]='\0'; } } else os_strncpy(value,dflt,length); }
bool ICACHE_FLASH_ATTR otb_conf_update_loc(int loc, char *val) { int len; bool rc = FALSE; otb_conf_struct *conf; DEBUG("CONF: otb_conf_update entry"); conf = &otb_conf_private; OTB_ASSERT((loc >= 1) && (loc <= 3)); len = os_strlen(val); if (len > (OTB_CONF_LOCATION_MAX_LEN)) { otb_cmd_rsp_append("location string too long", val); goto EXIT_LABEL; } switch (loc) { case 1: os_strncpy(conf->loc.loc1, val, OTB_CONF_LOCATION_MAX_LEN); break; case 2: os_strncpy(conf->loc.loc2, val, OTB_CONF_LOCATION_MAX_LEN); break; case 3: os_strncpy(conf->loc.loc3, val, OTB_CONF_LOCATION_MAX_LEN); break; default: OTB_ASSERT(FALSE); goto EXIT_LABEL; break; } rc = otb_conf_update(conf); if (!rc) { ERROR("CONF: Failed to update config"); otb_cmd_rsp_append("internal error"); } EXIT_LABEL: DEBUG("CONF: otb_conf_update exit"); return rc; }
/************************************************************** * constructor/destructor **************************************************************/ v_dataViewQos u_dataViewQosNew( v_dataViewQos tmpl) { v_dataViewQos q; u_result result; int len; q = os_malloc(sizeof(C_STRUCT(v_dataViewQos))); if (q != NULL) { if (tmpl != NULL) { /* Copy non-reference fields */ *q = *tmpl; /* Copy reference fields */ if (tmpl->userKey.enable){ if (tmpl->userKey.expression != NULL) { len = strlen(tmpl->userKey.expression); q->userKey.expression = os_malloc(len+1); os_strncpy(q->userKey.expression, tmpl->userKey.expression, len); q->userKey.expression[len] = 0; } else { q->userKey.expression = NULL; } } } else { result = u_dataViewQosInit(q); if (result != U_RESULT_OK) { u_dataViewQosFree(q); q = NULL; } } } return q; }
static int broadcom_ioctl(struct wpa_driver_broadcom_data *drv, int cmd, void *buf, int len) { struct ifreq ifr; wl_ioctl_t ioc; int ret = 0; wpa_printf(MSG_MSGDUMP, "BROADCOM: wlioctl(%s,%d,len=%d,val=%p)", drv->ifname, cmd, len, buf); /* wpa_hexdump(MSG_MSGDUMP, "BROADCOM: wlioctl buf", buf, len); */ ioc.cmd = cmd; ioc.buf = buf; ioc.len = len; os_strncpy(ifr.ifr_name, drv->ifname, IFNAMSIZ); ifr.ifr_data = (caddr_t) &ioc; if ((ret = ioctl(drv->ioctl_sock, SIOCDEVPRIVATE, &ifr)) < 0) { if (cmd != WLC_GET_MAGIC) perror(ifr.ifr_name); wpa_printf(MSG_MSGDUMP, "BROADCOM: wlioctl cmd=%d res=%d", cmd, ret); } return ret; }
int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf, size_t buf_len ) { struct i802_bss *bss = priv; struct wpa_driver_nl80211_data *drv = bss->drv; struct ifreq ifr; android_wifi_priv_cmd priv_cmd; int ret = 0; if (os_strcasecmp(cmd, "STOP") == 0) { linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0); wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED"); } else if (os_strcasecmp(cmd, "START") == 0) { linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1); wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STARTED"); } else if (os_strcasecmp(cmd, "MACADDR") == 0) { u8 macaddr[ETH_ALEN] = {}; ret = linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname, macaddr); if (!ret) ret = os_snprintf(buf, buf_len, "Macaddr = " MACSTR "\n", MAC2STR(macaddr)); } else { /* Use private command */ memset(&ifr, 0, sizeof(ifr)); memset(&priv_cmd, 0, sizeof(priv_cmd)); os_memcpy(buf, cmd, strlen(cmd) + 1); os_strncpy(ifr.ifr_name, bss->ifname, IFNAMSIZ); priv_cmd.buf = buf; priv_cmd.used_len = buf_len; priv_cmd.total_len = buf_len; ifr.ifr_data = &priv_cmd; if ((ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr)) < 0) { wpa_printf(MSG_ERROR, "%s: failed to issue private commands\n", __func__); } else { drv_errors = 0; ret = 0; if ((os_strcasecmp(cmd, "LINKSPEED") == 0) || (os_strcasecmp(cmd, "RSSI") == 0) || (os_strcasecmp(cmd, "GETBAND") == 0) ) ret = strlen(buf); else if (os_strcasecmp(cmd, "COUNTRY") == 0) wpa_supplicant_event(drv->ctx, EVENT_CHANNEL_LIST_CHANGED, NULL); else if (os_strncasecmp(cmd, "SETBAND", 7) == 0) wpa_printf(MSG_DEBUG, "%s: %s ", __func__, cmd); else if (os_strcasecmp(cmd, "P2P_DEV_ADDR") == 0) wpa_printf(MSG_DEBUG, "%s: P2P: Device address ("MACSTR")", __func__, MAC2STR(buf)); else if (os_strcasecmp(cmd, "P2P_SET_PS") == 0) wpa_printf(MSG_DEBUG, "%s: P2P: %s ", __func__, buf); else if (os_strcasecmp(cmd, "P2P_SET_NOA") == 0) wpa_printf(MSG_DEBUG, "%s: P2P: %s ", __func__, buf); else wpa_printf(MSG_DEBUG, "%s %s len = %d, %d", __func__, buf, ret, strlen(buf)); } } return ret; }
c_iter c_splitString( const c_char *str, const c_char *delimiters) { const c_char *head, *tail; c_char *nibble; c_iter iter = NULL; c_long length; if (str == NULL) return NULL; tail = str; while (*tail != '\0') { head = c_skipUntil(tail,delimiters); length = abs((c_address)head - (c_address)tail); if (length != 0) { length++; nibble = (c_string)os_malloc(length); os_strncpy(nibble,tail,length); nibble[length-1]=0; iter = c_iterAppend(iter,nibble); } tail = head; if (c_isOneOf(*tail,delimiters)) tail++; } return iter; }
v_partitionPolicyI v_partitionPolicyRemove( v_partitionPolicyI p, const c_char *expr, c_base base) { v_partitionPolicyI newPolicy; c_char *str; c_char *start; /* start of expr in p */ os_size_t len; newPolicy.v = NULL; if (p.v != NULL) { if (strcmp(p.v, expr) != 0) { len = strlen(p.v); str = os_malloc(len + 1); start = strstr(p.v, expr); assert(start != NULL); assert((c_address)start >= (c_address)p.v); os_strncpy(str, p.v, (c_address)start - (c_address)p.v); /* includes ',' */ str[(c_address)start - (c_address)p.v] = 0; /* make '\0' terminated */ if (strcmp(start, expr) != 0) { /* not at the end */ os_strcat(str, (c_char *)((c_address)start + strlen(expr) + 1 /* , */)); } newPolicy.v = c_stringNew(base, str); os_free(str); } } return newPolicy; }
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 = os_zalloc(sizeof(struct l2_packet_data)); if (l2 == NULL) return NULL; os_strncpy(l2->ifname, ifname, sizeof(l2->ifname)); l2->rx_callback = rx_callback; l2->rx_callback_ctx = rx_callback_ctx; l2->l2_hdr = l2_hdr; if (eth_get(l2->ifname, l2->own_addr) < 0) { fprintf(stderr, "Failed to get link-level address for " "interface '%s'.\n", l2->ifname); os_free(l2); return NULL; } if (l2_packet_init_libpcap(l2, protocol)) { os_free(l2); return NULL; } return l2; }
void token_string(char *into, char *json, jsmntok_t t) { char tv[100]; os_strncpy(tv, json+t.start, t.end-t.start); tv[t.end-t.start] = 0; //print(tv); strcpy(into, tv); }
static void * wpa_driver_ipw_init(void *ctx, const char *ifname) { struct wpa_driver_ipw_data *drv; int ver; wpa_printf(MSG_DEBUG, "%s is called", __FUNCTION__); drv = os_zalloc(sizeof(*drv)); if (drv == NULL) return NULL; drv->wext = wpa_driver_wext_init(ctx, ifname); if (drv->wext == NULL) { os_free(drv); return NULL; } ver = wpa_driver_wext_get_version(drv->wext); if (ver >= 18) { wpa_printf(MSG_WARNING, "Linux wireless extensions version %d " "detected.", ver); wpa_printf(MSG_WARNING, "ipw2x00 driver uses driver_wext " "(-Dwext) instead of driver_ipw."); } drv->ctx = ctx; os_strncpy(drv->ifname, ifname, sizeof(drv->ifname)); drv->sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->sock < 0) { wpa_driver_wext_deinit(drv->wext); os_free(drv); return NULL; } return drv; }
void ICACHE_FLASH_ATTR syslog_setup( char *hostname, int port, const char *app_name, const char **procs, const SYSLOG_MSG *msgs) { char *buffer = NULL; int ii; sint16 rc; syslog_ip_address = (char *)os_zalloc(SYSLOG_IP_LEN); buffer = (char *)os_zalloc(SYSLOG_BUF_SIZE * SYSLOG_STACK_DEPTH); for (ii = 0; ii < SYSLOG_STACK_DEPTH; ii++) { syslog_stack[ii] = buffer; buffer += SYSLOG_BUF_SIZE; } syslog_conn = (struct espconn *)os_zalloc(sizeof(struct espconn)); syslog_udp = (esp_udp *)os_zalloc(sizeof(esp_udp)); syslog_hostname = (char *)os_zalloc(SYSLOG_MAX_HOSTNAME); syslog_app_name = app_name; syslog_procs = procs; syslog_msgs = msgs; os_strncpy(syslog_hostname, hostname, SYSLOG_MAX_HOSTNAME); os_strcpy(syslog_ip_address, SYSLOG_DUMMY_IP); syslog_conn->type = ESPCONN_UDP; syslog_conn->proto.udp = syslog_udp; syslog_conn->proto.udp->local_port = espconn_port(); syslog_conn->proto.udp->remote_port = port; // // CONSOLE("SYSLOG - setup: %s:%d, rc: %d", hostname, port, rc); }
int ICACHE_FLASH_ATTR cgiMenu(HttpdConnData *connData) { if (connData->conn==NULL) return HTTPD_CGI_DONE; // Connection aborted. Clean up. char buff[1024]; // don't use jsonHeader so the response does get cached httpdStartResponse(connData, 200); httpdHeader(connData, "Cache-Control", "max-age=3600, must-revalidate"); httpdHeader(connData, "Content-Type", "application/json"); httpdEndHeaders(connData); // limit hostname to 12 chars char name[13]; os_strncpy(name, flashConfig.hostname, 12); name[12] = 0; // construct json response os_sprintf(buff, "{ " "\"menu\": [ " "\"Overview\", \"/home.html\", " "\"WiFi Console\", \"/console.html\", " "\"WiFi\", \"/wifi/wifi.html\", " #ifdef MQTT "\"Connectivity\", \"/mqtt.html\", " #endif "\"Debug log\", \"/log.html\"" " ], " "\"version\": \"%s\", " "\"name\": \"%s\"" " }", esp_link_version, name); httpdSend(connData, buff, -1); return HTTPD_CGI_DONE; }
int l2_packet_get_ip_addr(struct l2_packet_data *l2, char *buf, size_t len) { int s; struct ifreq ifr; struct sockaddr_in *saddr; s = socket(PF_INET, SOCK_DGRAM, 0); if (s < 0) { perror("socket"); return -1; } os_memset(&ifr, 0, sizeof(ifr)); os_strncpy(ifr.ifr_name, l2->ifname, sizeof(ifr.ifr_name)); if (ioctl(s, SIOCGIFADDR, &ifr) < 0) { if (errno != EADDRNOTAVAIL) perror("ioctl[SIOCGIFADDR]"); close(s); return -1; } close(s); saddr = (struct sockaddr_in *) &ifr.ifr_addr; if (saddr->sin_family != AF_INET) return -1; os_snprintf(buf, len, "%s", inet_ntoa(saddr->sin_addr)); 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 = os_zalloc(sizeof(struct l2_packet_data)); if (l2 == NULL) return NULL; os_strncpy(l2->ifname, ifname, sizeof(l2->ifname)); l2->rx_callback = rx_callback; l2->rx_callback_ctx = rx_callback_ctx; l2->l2_hdr = l2_hdr; #ifdef CONFIG_WINPCAP if (own_addr) os_memcpy(l2->own_addr, own_addr, ETH_ALEN); #else /* CONFIG_WINPCAP */ if (l2_packet_init_libdnet(l2)) return NULL; #endif /* CONFIG_WINPCAP */ if (l2_packet_init_libpcap(l2, protocol)) { #ifndef CONFIG_WINPCAP eth_close(l2->eth); #endif /* CONFIG_WINPCAP */ os_free(l2); return NULL; } return l2; }
void * wpa_driver_awext_init(void *ctx, const char *ifname) { struct wpa_driver_awext_data *drv; drv = os_zalloc(sizeof(*drv)); if (drv == NULL) return NULL; drv->wext = wpa_driver_wext_init(ctx, ifname); if (drv->wext == NULL) { os_free(drv); return NULL; } drv->ctx = ctx; os_strncpy(drv->ifname, ifname, sizeof(drv->ifname)); drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->ioctl_sock < 0) { wpa_driver_wext_deinit(drv->wext); os_free(drv); return NULL; } return drv; }
static int wpa_driver_tista_pmksa(struct wpa_driver_ti_data *drv, u32 cmd, const u8 *bssid, const u8 *pmkid) { struct iwreq iwr; struct iw_pmksa pmksa; int ret = 0; os_memset(&iwr, 0, sizeof(iwr)); os_strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); os_memset(&pmksa, 0, sizeof(pmksa)); pmksa.cmd = cmd; pmksa.bssid.sa_family = ARPHRD_ETHER; if (bssid) os_memcpy(pmksa.bssid.sa_data, bssid, ETH_ALEN); if (pmkid) { os_memcpy(pmksa.pmkid, pmkid, IW_PMKID_LEN); wpa_printf(MSG_DEBUG, "pmkid %s", pmkid); } iwr.u.data.pointer = (caddr_t)&pmksa; iwr.u.data.length = sizeof(pmksa); if (ioctl(drv->ioctl_sock, SIOCSIWPMKSA, &iwr) < 0) { if (errno != EOPNOTSUPP) perror("ioctl[SIOCSIWPMKSA]"); ret = -1; } return ret; }
static int wpa_driver_madwifi_scan(void *priv, const u8 *ssid, size_t ssid_len) { struct wpa_driver_madwifi_data *drv = priv; struct iwreq iwr; int ret = 0; os_memset(&iwr, 0, sizeof(iwr)); os_strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); /* set desired ssid before scan */ /* FIX: scan should not break the current association, so using * set_ssid may not be the best way of doing this.. */ if (wpa_driver_wext_set_ssid(drv->wext, ssid, ssid_len) < 0) ret = -1; if (ioctl(drv->sock, SIOCSIWSCAN, &iwr) < 0) { perror("ioctl[SIOCSIWSCAN]"); ret = -1; } /* * madwifi delivers a scan complete event so no need to poll, but * register a backup timeout anyway to make sure that we recover even * if the driver does not send this event for any reason. This timeout * will only be used if the event is not delivered (event handler will * cancel the timeout). */ eloop_register_timeout(30, 0, wpa_driver_wext_scan_timeout, drv->wext, drv->ctx); return ret; }
void* _os_malloc(const int8 *aFileName, int32 aLineNo, IN int32 aSize) { void *ptr = malloc(aSize); #ifdef MEM_TRACE MallocPtrLinkedList *mallocPtrLinkedList = NULL; MallocStruct *mallocStruct = (MallocStruct*)malloc(sizeof(MallocStruct)); if(NULL == mallocStruct){ goto _os_malloc; } if(os_strlen((int8*)aFileName)){ os_strncpy(mallocStruct->FileName,aFileName,sizeof(mallocStruct->FileName)); } mallocStruct->LineNo = aLineNo; mallocStruct->Size = aSize; mallocStruct->Ptr = ptr; mallocPtrLinkedList = (MallocPtrLinkedList*)malloc(sizeof(MallocPtrLinkedList)); if(NULL == mallocPtrLinkedList){ free(mallocStruct); goto _os_malloc; } mallocPtrLinkedList->mallocStruct = mallocStruct; mallocPtrLinkedList->NextPtr = NULL; if(gMallocPtrLinkedListStartPtr == NULL){ gMallocPtrLinkedListStartPtr = gMallocPtrLinkedListLastPtr = mallocPtrLinkedList; }else{ gMallocPtrLinkedListLastPtr->NextPtr = mallocPtrLinkedList; gMallocPtrLinkedListLastPtr = mallocPtrLinkedList; } _os_malloc: #endif return ptr; }
void initslave(){ char * ap = CLIENT_AP; char * pass = MASTER_PASSWORD; wifi_set_opmode(STATION_MODE); wifi_softap_get_config(&apconf); os_strncpy((char*)apconf.ssid, ap, 32); os_strncpy((char*)apconf.password, pass, 64); apconf.authmode = AUTH_WPA_WPA2_PSK; apconf.max_connection = 20; apconf.ssid_hidden = 0; wifi_softap_set_config(&apconf); scan_slave(); reg_addlistener(callback_slave, 0x32); os_timer_setfn(&watchdog_slave, (os_timer_func_t *)slave_sendalive, NULL); os_timer_arm(&watchdog_slave, 2000, 0); }
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; }
static void wrapd_wireless_event_wireless(struct wrap_demon *aptr, struct ifinfomsg *ifi, char *data, int len) { struct iw_event iwe_buf, *iwe = &iwe_buf; char *pos, *end, *custom; char parent[IFNAMSIZ] = {0}; char child[IFNAMSIZ] = {0}; u_int32_t flags = WRAPD_PSTA_FLAG_OPEN; int i; wrapd_ifindex_to_ifname(aptr, ifi->ifi_index, child); for (i = 0; i < HOSTAPD_CNT; i ++) { if ((wrapd_hostapd_conn[i]) && (os_strcmp(child, ap_ifname[i]) == 0)) return; } pos = data; end = data + len; while (pos + IW_EV_LCP_LEN <= end) { //+4 os_memcpy(&iwe_buf, pos, IW_EV_LCP_LEN); if (iwe->len <= IW_EV_LCP_LEN) return; custom = pos + IW_EV_POINT_LEN; if (iwe->cmd == IWEVEXPIRED || iwe->cmd == IWEVREGISTERED ){ os_memcpy(&iwe_buf, pos, sizeof(struct iw_event)); custom += IW_EV_POINT_OFF; } switch (iwe->cmd) { case IWEVEXPIRED: wrapd_psta_remove(aptr,(u8 *) iwe->u.addr.sa_data); break; case IWEVREGISTERED: if (dbdc_ifname) { os_strncpy(parent, dbdc_ifname, IFNAMSIZ); parent[IFNAMSIZ - 1] = '\0'; flags &= ~WRAPD_PSTA_FLAG_MAT; } else { wrapd_ifindex_to_parent_ifname(aptr, ifi->ifi_index, parent); flags |= WRAPD_PSTA_FLAG_MAT; } wrapd_psta_add(aptr, parent, child, (u8 *)(iwe->u.addr.sa_data), flags); break; case IWEVASSOCREQIE: case IWEVCUSTOM: break; } pos += iwe->len; } }
// Perform a TCP command: parse the command and do the right thing. // Returns true on success. bool ICACHE_FLASH_ATTR tcpClientCommand(uint8_t chan, char cmd, char *cmdBuf) { TcpConn *tci; char *hostname; char *port; // copy the command so we can modify it char buf[128]; os_strncpy(buf, cmdBuf, 128); buf[127] = 0; switch (cmd) { //== TCP Connect command case 'T': hostname = buf; port = hostname; while (*port != 0 && *port != ':') port++; if (*port != ':') break; *port = 0; port++; int portInt = atoi(port); if (portInt < 1 || portInt > 65535) break; // allocate a connection tci = tcpConnAlloc(chan); if (tci == NULL) break; tci->state = TCP_dns; tci->tcp->remote_port = portInt; // start the DNS resolution os_printf("TCP %p resolving %s for chan %d (conn=%p)\n", tci, hostname, chan ,tci->conn); ip_addr_t ip; err_t err = espconn_gethostbyname(tci->conn, hostname, &ip, tcpClientHostnameCb); if (err == ESPCONN_OK) { // dns cache hit, got the IP address, fake the callback (sigh) os_printf("TCP DNS hit\n"); tcpClientHostnameCb(hostname, &ip, tci->conn); } else if (err != ESPCONN_INPROGRESS) { tcpConnFree(tci); break; } return true; //== TCP Close/disconnect command case 'C': os_printf("TCP closing chan %d\n", chan); tci = tcpConn+chan; if (tci->state > TCP_idle) { tci->state = TCP_idle; // hackish... espconn_disconnect(tci->conn); } break; } return false; }