//addr format: xx:xx:xx:xx:xx:xx
void
wrapd_load_vma_list(const char *conf_file, wrapd_hdl_t *handle)
{
struct wrap_demon *aptr = (struct wrap_demon *)handle;
FILE *f;
char buf[256], *pos, *start;
int line = 0, off =0;
wrapd_printf("oma conf file(%s)", conf_file);
f = fopen(conf_file, "r");
if (f == NULL) {
wrapd_printf("Cant open oma conf file(%s)", conf_file);
return;
}
while ((fgets(buf, sizeof(buf), f)) && (off < WRAP_MAX_PSTA_NUM)) {
line ++;
if (buf[0] == '#')
continue;
pos = buf;
while (*pos != '\0') {
if (*pos == '\n') {
*pos = '\0';
break;
}
pos ++;
}
pos = os_strchr(buf, ':');
if ((pos == NULL) || (pos - buf < 2) || (os_strlen(pos) < 15)) {
wrapd_printf("Invalid addr in line %d", line);
continue;
}
start = pos - 2;
start[17] = '\0';
if((start[5] != ':') ||(start[8] != ':') ||(start[11] != ':')|| (start[14] != ':')){
wrapd_printf("Invalid addr in line %d", line);
continue;
}
if (char2addr(start) != 0) {
wrapd_printf("Invalid addr in line %d", line);
continue;
}
os_memcpy(aptr->psta[off].vma, start, IEEE80211_ADDR_LEN);
aptr->psta[off].vma_loaded = 1;
aptr->psta[off].added = 0;
aptr->psta[off].connected = 0;
wrapd_printf("Load VMA(%02x:%02x:%02x:%02x:%02x:%02x) to off(%d) in line %d",
aptr->psta[off].vma[0], aptr->psta[off].vma[1], aptr->psta[off].vma[2],
aptr->psta[off].vma[3], aptr->psta[off].vma[4], aptr->psta[off].vma[5],
off, line);
off ++;
}
close((int)f);
}
static int wpa_supplicant_mesh_init(struct wpa_supplicant *wpa_s,
struct wpa_ssid *ssid)
{
struct hostapd_iface *ifmsh;
struct hostapd_data *bss;
struct hostapd_config *conf;
struct mesh_conf *mconf;
int basic_rates_erp[] = { 10, 20, 55, 60, 110, 120, 240, -1 };
static int default_groups[] = { 19, 20, 21, 25, 26, -1 };
size_t len;
int rate_len;
if (!wpa_s->conf->user_mpm) {
/* not much for us to do here */
wpa_msg(wpa_s, MSG_WARNING,
"user_mpm is not enabled in configuration");
return 0;
}
wpa_s->ifmsh = ifmsh = os_zalloc(sizeof(*wpa_s->ifmsh));
if (!ifmsh)
return -ENOMEM;
ifmsh->drv_flags = wpa_s->drv_flags;
ifmsh->num_bss = 1;
ifmsh->bss = os_calloc(wpa_s->ifmsh->num_bss,
sizeof(struct hostapd_data *));
if (!ifmsh->bss)
goto out_free;
ifmsh->bss[0] = bss = os_zalloc(sizeof(struct hostapd_data));
if (!bss)
goto out_free;
os_memcpy(bss->own_addr, wpa_s->own_addr, ETH_ALEN);
bss->driver = wpa_s->driver;
bss->drv_priv = wpa_s->drv_priv;
bss->iface = ifmsh;
bss->mesh_sta_free_cb = mesh_mpm_free_sta;
wpa_s->assoc_freq = ssid->frequency;
wpa_s->current_ssid = ssid;
/* setup an AP config for auth processing */
conf = hostapd_config_defaults();
if (!conf)
goto out_free;
bss->conf = *conf->bss;
bss->conf->start_disabled = 1;
bss->conf->mesh = MESH_ENABLED;
bss->conf->ap_max_inactivity = wpa_s->conf->mesh_max_inactivity;
bss->iconf = conf;
ifmsh->conf = conf;
ifmsh->bss[0]->max_plinks = wpa_s->conf->max_peer_links;
os_strlcpy(bss->conf->iface, wpa_s->ifname, sizeof(bss->conf->iface));
mconf = mesh_config_create(ssid);
if (!mconf)
goto out_free;
ifmsh->mconf = mconf;
/* need conf->hw_mode for supported rates. */
if (ssid->frequency == 0) {
conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
conf->channel = 1;
} else {
conf->hw_mode = ieee80211_freq_to_chan(ssid->frequency,
&conf->channel);
}
if (conf->hw_mode == NUM_HOSTAPD_MODES) {
wpa_printf(MSG_ERROR, "Unsupported mesh mode frequency: %d MHz",
ssid->frequency);
goto out_free;
}
if (ssid->mesh_basic_rates == NULL) {
/*
* XXX: Hack! This is so an MPM which correctly sets the ERP
* mandatory rates as BSSBasicRateSet doesn't reject us. We
* could add a new hw_mode HOSTAPD_MODE_IEEE80211G_ERP, but
* this is way easier. This also makes our BSSBasicRateSet
* advertised in beacons match the one in peering frames, sigh.
*/
if (conf->hw_mode == HOSTAPD_MODE_IEEE80211G) {
conf->basic_rates = os_malloc(sizeof(basic_rates_erp));
if (!conf->basic_rates)
goto out_free;
os_memcpy(conf->basic_rates, basic_rates_erp,
sizeof(basic_rates_erp));
}
} else {
rate_len = 0;
while (1) {
if (ssid->mesh_basic_rates[rate_len] < 1)
break;
rate_len++;
}
conf->basic_rates = os_calloc(rate_len + 1, sizeof(int));
if (conf->basic_rates == NULL)
goto out_free;
os_memcpy(conf->basic_rates, ssid->mesh_basic_rates,
rate_len * sizeof(int));
conf->basic_rates[rate_len] = -1;
}
if (hostapd_setup_interface(ifmsh)) {
wpa_printf(MSG_ERROR,
"Failed to initialize hostapd interface for mesh");
return -1;
}
if (wpa_drv_init_mesh(wpa_s)) {
wpa_msg(wpa_s, MSG_ERROR, "Failed to init mesh in driver");
return -1;
}
if (mconf->security != MESH_CONF_SEC_NONE) {
if (ssid->passphrase == NULL) {
wpa_printf(MSG_ERROR,
"mesh: Passphrase for SAE not configured");
goto out_free;
}
bss->conf->wpa = ssid->proto;
bss->conf->wpa_key_mgmt = ssid->key_mgmt;
if (wpa_s->conf->sae_groups &&
wpa_s->conf->sae_groups[0] > 0) {
wpas_mesh_copy_groups(bss, wpa_s);
} else {
bss->conf->sae_groups =
os_malloc(sizeof(default_groups));
if (!bss->conf->sae_groups)
goto out_free;
os_memcpy(bss->conf->sae_groups, default_groups,
sizeof(default_groups));
}
len = os_strlen(ssid->passphrase);
bss->conf->ssid.wpa_passphrase =
dup_binstr(ssid->passphrase, len);
wpa_s->mesh_rsn = mesh_rsn_auth_init(wpa_s, mconf);
if (!wpa_s->mesh_rsn)
goto out_free;
}
wpa_supplicant_conf_ap_ht(wpa_s, ssid, conf);
return 0;
out_free:
wpa_supplicant_mesh_deinit(wpa_s);
return -ENOMEM;
}
/* xml_add_tagged_data -- format tagged data as a new xml line.
*
* tag must not have any special chars.
* data may have special chars, which are escaped.
*/
void xml_add_tagged_data(struct wpabuf *buf, const char *tag, const char *data)
{
wpabuf_printf(buf, "<%s>", tag);
xml_data_encode(buf, data, os_strlen(data));
wpabuf_printf(buf, "</%s>\n", tag);
}
static int str_starts(const char *str, const char *start)
{
return os_strncmp(str, start, os_strlen(start)) == 0;
}
int hostapd_init_wps(struct hostapd_data *hapd,
struct hostapd_bss_config *conf)
{
struct wps_context *wps;
struct wps_registrar_config cfg;
if (conf->wps_state == 0) {
hostapd_wps_clear_ies(hapd);
return 0;
}
wps = os_zalloc(sizeof(*wps));
if (wps == NULL)
return -1;
wps->cred_cb = hostapd_wps_cred_cb;
wps->event_cb = hostapd_wps_event_cb;
wps->cb_ctx = hapd;
os_memset(&cfg, 0, sizeof(cfg));
wps->wps_state = hapd->conf->wps_state;
wps->ap_setup_locked = hapd->conf->ap_setup_locked;
if (is_nil_uuid(hapd->conf->uuid)) {
const u8 *uuid;
uuid = get_own_uuid(hapd->iface);
if (uuid) {
os_memcpy(wps->uuid, uuid, UUID_LEN);
#if 0 //peter-jc To follow MR0 wpa_hexdump modification
wpa_hexdump(MSG_DEBUG, "WPS: Clone UUID from another "
"interface", wps->uuid, UUID_LEN);
#endif
} else {
uuid_gen_mac_addr(hapd->own_addr, wps->uuid);
#if 0 //peter-jc To follow MR0 wpa_hexdump modification
wpa_hexdump(MSG_DEBUG, "WPS: UUID based on MAC "
"address", wps->uuid, UUID_LEN);
#endif
}
} else {
os_memcpy(wps->uuid, hapd->conf->uuid, UUID_LEN);
#if 0 //peter-jc To follow MR0 wpa_hexdump modification
wpa_hexdump(MSG_DEBUG, "WPS: Use configured UUID",
wps->uuid, UUID_LEN);
#endif
}
wps->ssid_len = hapd->conf->ssid.ssid_len;
os_memcpy(wps->ssid, hapd->conf->ssid.ssid, wps->ssid_len);
wps->ap = 1;
os_memcpy(wps->dev.mac_addr, hapd->own_addr, ETH_ALEN);
wps->dev.device_name = hapd->conf->device_name ?
os_strdup(hapd->conf->device_name) : NULL;
wps->dev.manufacturer = hapd->conf->manufacturer ?
os_strdup(hapd->conf->manufacturer) : NULL;
wps->dev.model_name = hapd->conf->model_name ?
os_strdup(hapd->conf->model_name) : NULL;
wps->dev.model_number = hapd->conf->model_number ?
os_strdup(hapd->conf->model_number) : NULL;
wps->dev.serial_number = hapd->conf->serial_number ?
os_strdup(hapd->conf->serial_number) : NULL;
wps->config_methods =
wps_config_methods_str2bin(hapd->conf->config_methods);
#ifdef CONFIG_WPS2
if ((wps->config_methods &
(WPS_CONFIG_DISPLAY | WPS_CONFIG_VIRT_DISPLAY |
WPS_CONFIG_PHY_DISPLAY)) == WPS_CONFIG_DISPLAY) {
wpa_printf(MSG_INFO, "WPS: Converting display to "
"virtual_display for WPS 2.0 compliance");
wps->config_methods |= WPS_CONFIG_VIRT_DISPLAY;
}
if ((wps->config_methods &
(WPS_CONFIG_PUSHBUTTON | WPS_CONFIG_VIRT_PUSHBUTTON |
WPS_CONFIG_PHY_PUSHBUTTON)) == WPS_CONFIG_PUSHBUTTON) {
wpa_printf(MSG_INFO, "WPS: Converting push_button to "
"virtual_push_button for WPS 2.0 compliance");
wps->config_methods |= WPS_CONFIG_VIRT_PUSHBUTTON;
}
#endif /* CONFIG_WPS2 */
os_memcpy(wps->dev.pri_dev_type, hapd->conf->device_type,
WPS_DEV_TYPE_LEN);
if (hostapd_wps_set_vendor_ext(hapd, wps) < 0) {
os_free(wps);
return -1;
}
wps->dev.os_version = WPA_GET_BE32(hapd->conf->os_version);
if (conf->wps_rf_bands) {
wps->dev.rf_bands = conf->wps_rf_bands;
} else {
wps->dev.rf_bands =
hapd->iconf->hw_mode == HOSTAPD_MODE_IEEE80211A ?
WPS_RF_50GHZ : WPS_RF_24GHZ; /* FIX: dualband AP */
}
if (conf->wpa & WPA_PROTO_RSN) {
if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK)
wps->auth_types |= WPS_AUTH_WPA2PSK;
if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X)
wps->auth_types |= WPS_AUTH_WPA2;
if (conf->rsn_pairwise & WPA_CIPHER_CCMP)
wps->encr_types |= WPS_ENCR_AES;
if (conf->rsn_pairwise & WPA_CIPHER_TKIP)
wps->encr_types |= WPS_ENCR_TKIP;
}
if (conf->wpa & WPA_PROTO_WPA) {
if (conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK)
wps->auth_types |= WPS_AUTH_WPAPSK;
if (conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X)
wps->auth_types |= WPS_AUTH_WPA;
if (conf->wpa_pairwise & WPA_CIPHER_CCMP)
wps->encr_types |= WPS_ENCR_AES;
if (conf->wpa_pairwise & WPA_CIPHER_TKIP)
wps->encr_types |= WPS_ENCR_TKIP;
}
if (conf->ssid.security_policy == SECURITY_PLAINTEXT) {
wps->encr_types |= WPS_ENCR_NONE;
wps->auth_types |= WPS_AUTH_OPEN;
} else if (conf->ssid.security_policy == SECURITY_STATIC_WEP) {
wps->encr_types |= WPS_ENCR_WEP;
if (conf->auth_algs & WPA_AUTH_ALG_OPEN)
wps->auth_types |= WPS_AUTH_OPEN;
if (conf->auth_algs & WPA_AUTH_ALG_SHARED)
wps->auth_types |= WPS_AUTH_SHARED;
} else if (conf->ssid.security_policy == SECURITY_IEEE_802_1X) {
wps->auth_types |= WPS_AUTH_OPEN;
if (conf->default_wep_key_len)
wps->encr_types |= WPS_ENCR_WEP;
else
wps->encr_types |= WPS_ENCR_NONE;
}
if (conf->ssid.wpa_psk_file) {
/* Use per-device PSKs */
} else if (conf->ssid.wpa_passphrase) {
wps->network_key = (u8 *) os_strdup(conf->ssid.wpa_passphrase);
wps->network_key_len = os_strlen(conf->ssid.wpa_passphrase);
} else if (conf->ssid.wpa_psk) {
wps->network_key = os_malloc(2 * PMK_LEN + 1);
if (wps->network_key == NULL) {
os_free(wps);
return -1;
}
wpa_snprintf_hex((char *) wps->network_key, 2 * PMK_LEN + 1,
conf->ssid.wpa_psk->psk, PMK_LEN);
wps->network_key_len = 2 * PMK_LEN;
} else if (conf->ssid.wep.keys_set && conf->ssid.wep.key[0]) {
wps->network_key = os_malloc(conf->ssid.wep.len[0]);
if (wps->network_key == NULL) {
os_free(wps);
return -1;
}
os_memcpy(wps->network_key, conf->ssid.wep.key[0],
conf->ssid.wep.len[0]);
wps->network_key_len = conf->ssid.wep.len[0];
}
if (conf->ssid.wpa_psk) {
os_memcpy(wps->psk, conf->ssid.wpa_psk->psk, PMK_LEN);
wps->psk_set = 1;
}
if (conf->wps_state == WPS_STATE_NOT_CONFIGURED) {
/* Override parameters to enable security by default */
wps->auth_types = WPS_AUTH_WPA2PSK | WPS_AUTH_WPAPSK;
wps->encr_types = WPS_ENCR_AES | WPS_ENCR_TKIP;
}
wps->ap_settings = conf->ap_settings;
wps->ap_settings_len = conf->ap_settings_len;
cfg.new_psk_cb = hostapd_wps_new_psk_cb;
cfg.set_ie_cb = hostapd_wps_set_ie_cb;
cfg.pin_needed_cb = hostapd_wps_pin_needed_cb;
cfg.reg_success_cb = hostapd_wps_reg_success_cb;
cfg.enrollee_seen_cb = hostapd_wps_enrollee_seen_cb;
cfg.cb_ctx = hapd;
cfg.skip_cred_build = conf->skip_cred_build;
cfg.extra_cred = conf->extra_cred;
cfg.extra_cred_len = conf->extra_cred_len;
cfg.disable_auto_conf = (hapd->conf->wps_cred_processing == 1) &&
conf->skip_cred_build;
if (conf->ssid.security_policy == SECURITY_STATIC_WEP)
cfg.static_wep_only = 1;
cfg.dualband = interface_count(hapd->iface) > 1;
if (cfg.dualband)
wpa_printf(MSG_DEBUG, "WPS: Dualband AP");
wps->registrar = wps_registrar_init(wps, &cfg);
if (wps->registrar == NULL) {
wpa_printf(MSG_ERROR, "Failed to initialize WPS Registrar");
os_free(wps->network_key);
os_free(wps);
return -1;
}
#ifdef CONFIG_WPS_UPNP
wps->friendly_name = hapd->conf->friendly_name;
wps->manufacturer_url = hapd->conf->manufacturer_url;
wps->model_description = hapd->conf->model_description;
wps->model_url = hapd->conf->model_url;
wps->upc = hapd->conf->upc;
#endif /* CONFIG_WPS_UPNP */
hostapd_register_probereq_cb(hapd, hostapd_wps_probe_req_rx, hapd);
hapd->wps = wps;
return 0;
}
//***********************************************************************
void ICACHE_FLASH_ATTR webSocketRecvCb(void *arg, char *data, unsigned short len) {
espconn *esp_connection = (espconn*)arg;
//received some data from webSocket connection
//webSocketDebug("In webSocketRecvCb\n");
// webSocketDebug("webSocket recv--->%s<----\n", data);
WSConnection *wsConnection = getWsConnection(esp_connection);
if (wsConnection == NULL) {
webSocketDebug("webSocket Heh?\n");
return;
}
//get the first occurrence of the key identifier
char *key = os_strstr(data, WS_KEY_IDENTIFIER);
// webSocketDebug("key-->%s<--\n", key );
if (key != NULL) {
// ------------------------ Handle the Handshake ------------------------
// webSocketDebug("In Handle the Handshake\n");
//Skip the identifier (that contains the space already)
key += os_strlen(WS_KEY_IDENTIFIER);
// webSocketDebug("keynow-->%s<--\n", key);
//the key ends at the newline
char *endSequence = os_strstr(key, HTML_HEADER_LINEEND);
// webSocketDebug("endSequency-->%s<--\n", endSequence);
if (endSequence != NULL) {
int keyLastChar = endSequence - key;
//we can throw away all the other data, only the key is interesting
key[keyLastChar] = '\0';
// webSocketDebug("keyTrimmed-->%s<--\n", key);
char acceptKey[100];
createWsAcceptKey(key, acceptKey, 100);
// webSocketDebug("acceptKey-->%s<--\n", acceptKey);
//now construct our message and send it back to the client
char responseMessage[strlen(WS_RESPONSE) + 100];
os_sprintf(responseMessage, WS_RESPONSE, acceptKey);
// webSocketDebug("responseMessage-->%s<--\n", responseMessage);
//send the response
espconn_sent(esp_connection, (uint8_t *)responseMessage, strlen(responseMessage));
wsConnection->status = STATUS_OPEN;
//call the connection callback
if (wsOnConnectionCallback != NULL) {
// webSocketDebug("Handle the Handshake 5\n");
wsOnConnectionCallback();
}
}
} else {
// ------------------------ Handle a Frame ------------------------
// webSocketDebug("In Handle a Frame\n");
WSFrame frame;
parseWsFrame(data, &frame);
if (frame.isMasked) {
unmaskWsPayload(frame.payloadData, frame.payloadLength, frame.maskingKey);
} else {
//we are the server, and need to shut down the connection
//if we receive an unmasked packet
// webSocketDebug("frame.isMasked=false closing connection\n");
closeWsConnection(wsConnection);
return;
}
// webSocketDebug("frame.payloadData-->%s<--\n", frame.payloadData);
if (frame.opcode == OPCODE_PING) {
// webSocketDebug("frame.opcode=OPCODE_PING\n");
sendWsMessage(wsConnection, frame.payloadData, frame.payloadLength, FLAG_FIN | OPCODE_PONG);
return;
}
if (frame.opcode == OPCODE_CLOSE) {
//gracefully shut down the connection
// webSocketDebug("frame.opcode=OPCODE_CLOSE, closeing connection\n");
closeWsConnection(wsConnection);
return;
}
if (wsConnection->onMessage != NULL) {
wsConnection->onMessage(frame.payloadData);
}
}
// webSocketDebug("Leaving webSocketRecvCb\n");
}
/*The main working flow of this demo:
a. start mesh function, searching for existing mesh network
b. if there is no mesh network, search AP cache to connect to a recorded router.
c. If we still failed to establish a connection, start ESP-TOUCH wait for configure.
d. If ESP-TOUCH time out, re-search mesh network and AP CACHE.
e. During the whole procedure,we can control and configure the light via a restful webserver.
f. ESP-NOW is the recently released function to control the light without any WiFi connection.You can find it in app_switch
*/
void ICACHE_FLASH_ATTR
light_main_flow()
{
UART_WaitTxFifoEmpty(0,50000);
uart_init(74880,74880);
user_DispAppInfo();
wifi_set_opmode(STATIONAP_MODE);
#if ESP_MESH_SUPPORT
wifi_station_set_auto_connect(0);
wifi_station_disconnect();
#else
wifi_station_set_auto_connect(1);
#endif
os_printf("SDK version:%s\n", system_get_sdk_version());
#if AP_CACHE
wifi_station_ap_number_set(AP_CACHE_NUMBER);
#endif
#if ESP_NOW_SUPPORT
/*We have added esp-now feature in the light project */
/*So that the lights in a certain MAC group can be easily controlled by an ESP-NOW controller*/
/*The sample code is in APP_CONTROLLER/APP_SWITCH*/
sp_MacInit();//csc add button Mac add and delet
light_EspnowInit();
#endif
#if 1
#if ESP_PLATFORM
/*Initialization of the peripheral drivers*/
/*For light demo , it is user_light_init();*/
/* Also check whether assigned ip addr by the router.If so, connect to ESP-server */
user_esp_platform_init_peripheral();
disp_heap(5);
#endif
/*Establish a udp socket to receive local device detect info.*/
/*Listen to the port 1025, as well as udp broadcast.
/*If receive a string of device_find_request, it reply its IP address and MAC.*/
user_devicefind_init();
disp_heap(6);
/*Establish a TCP server for http(with JSON) POST or GET command to communicate with the device.*/
/*You can find the command in "2B-SDK-Espressif IoT Demo.pdf" to see the details.*/
/*the JSON command for curl is like:*/
/*3 Channel mode: curl -X POST -H "Content-Type:application/json" -d "{\"period\":1000,\"rgb\":{\"red\":16000,\"green\":16000,\"blue\":16000}}" http://192.168.4.1/config?command=light */
/*5 Channel mode: curl -X POST -H "Content-Type:application/json" -d "{\"period\":1000,\"rgb\":{\"red\":16000,\"green\":16000,\"blue\":16000,\"cwhite\":3000,\"wwhite\",3000}}" http://192.168.4.1/config?command=light */
/***********NOTE!!**************/
/*in MESH mode, you need to add "sip","sport" and "mdev_mac" fields to send command to the desired device*/
/*see details in MESH documentation*/
/*MESH INTERFACE IS AT PORT 8000*/
#if ESP_WEB_SUPPORT
//Initialize DNS server for captive portal
captdnsInit();
//Initialize espfs containing static webpages
espFsInit((void*)(webpages_espfs_start));
//Initialize webserver
httpdInit(builtInUrls, SERVER_PORT);
//user_webserver_init(SERVER_PORT);
#else
#ifdef SERVER_SSL_ENABLE
user_webserver_init(SERVER_SSL_PORT);
#else
user_webserver_init(SERVER_PORT);
#endif
#endif
#endif
//In debug mode, if you restart the light within 2 seconds, it will get into softap mode and wait for local upgrading firmware.
//Restart again, it will clear the system param and set to default status.
#if ESP_DEBUG_MODE
extern struct esp_platform_saved_param esp_param;
if(esp_param.reset_flg == MODE_APMODE){
os_printf("==================\r\n");
os_printf("RESET FLG==2,STATIONAP_MODE \r\n");
os_printf("==================\r\n");
#if ESP_MESH_SUPPORT
user_DeviceFindRespSet(false);
#endif
struct softap_config config_softap;
char ssid[33]={0};
wifi_softap_get_config(&config_softap);
os_memset(config_softap.password, 0, sizeof(config_softap.password));
os_memset(config_softap.ssid, 0, sizeof(config_softap.ssid));
os_sprintf(ssid,"ESP_%06X",system_get_chip_id());
os_memcpy(config_softap.ssid, ssid, os_strlen(ssid));
config_softap.ssid_len = os_strlen(ssid);
config_softap.authmode = AUTH_OPEN;
wifi_softap_set_config(&config_softap);
os_printf("SET STATION-AP MODE\r\n");
wifi_set_opmode(STATIONAP_MODE);
user_esp_platform_set_reset_flg(MODE_RESET);
#if ESP_WEB_SUPPORT
os_printf("WEBSERVER INIT...");
//Initialize DNS server for captive portal
captdnsInit();
//Initialize espfs containing static webpages
espFsInit((void*)(webpages_espfs_start));
//Initialize webserver
httpdInit(builtInUrls, SERVER_PORT);
#endif
os_timer_disarm(&reset_flg_t);
os_timer_setfn(&reset_flg_t,user_esp_platform_set_reset_flg,MODE_NORMAL);
os_timer_arm(&reset_flg_t,2000,0);
user_light_set_duty(0, LIGHT_RED);
user_light_set_duty(0, LIGHT_GREEN);
user_light_set_duty(0, LIGHT_BLUE);
user_light_set_duty(22222, LIGHT_WARM_WHITE);
user_light_set_duty(22222, LIGHT_COLD_WHITE);
os_delay_us(5000);
light_ShowDevLevel(5);
return;
}
#if ESP_RESET_DEBUG_EN
else if(esp_param.reset_flg == MODE_RESET){
os_printf("==================\r\n");
os_printf("RESET FLG==1,RESET IN 200 MS \r\n");
os_printf("==================\r\n");
user_esp_platform_set_reset_flg(MODE_APMODE);
os_timer_disarm(&reset_flg_t);
os_timer_setfn(&reset_flg_t,user_esp_platform_reset_default,0);
os_timer_arm(&reset_flg_t,200,0);
}
else{
os_printf("==================\r\n");
os_printf("RESET FLG==0,NORMAL MODE \r\n");
os_printf("==================\r\n");
user_esp_platform_set_reset_flg(MODE_APMODE);
os_timer_disarm(&reset_flg_t);
os_timer_setfn(&reset_flg_t,user_esp_platform_set_reset_flg,0);
os_timer_arm(&reset_flg_t,2000,0);
}
#endif
#endif
#if ESP_MESH_SUPPORT
/*initialize mesh network.
1. search for existing mesh.
2. if failed , try connecting recorded router.
*/
user_MeshParamInit();
user_MeshStart();
#elif ESP_TOUCH_SUPPORT
esptouch_FlowStart();
#endif
}
/**
* eap_peer_select_phase2_methods - Select phase 2 EAP method
* @config: Pointer to the network configuration
* @prefix: 'phase2' configuration prefix, e.g., "auth="
* @types: Buffer for returning allocated list of allowed EAP methods
* @num_types: Buffer for returning number of allocated EAP methods
* Returns: 0 on success, -1 on failure
*
* This function is used to parse EAP method list and select allowed methods
* for Phase2 authentication.
*/
int eap_peer_select_phase2_methods(struct eap_peer_config *config,
const char *prefix,
struct eap_method_type **types,
size_t *num_types)
{
char *start, *pos, *buf;
struct eap_method_type *methods = NULL, *_methods;
u8 method;
size_t num_methods = 0, prefix_len;
if (config == NULL || config->phase2 == NULL)
goto get_defaults;
start = buf = os_strdup(config->phase2);
if (buf == NULL)
return -1;
prefix_len = os_strlen(prefix);
while (start && *start != '\0') {
int vendor;
pos = os_strstr(start, prefix);
if (pos == NULL)
break;
if (start != pos && *(pos - 1) != ' ') {
start = pos + prefix_len;
continue;
}
start = pos + prefix_len;
pos = os_strchr(start, ' ');
if (pos)
*pos++ = '\0';
method = eap_get_phase2_type(start, &vendor);
if (vendor == EAP_VENDOR_IETF && method == EAP_TYPE_NONE) {
wpa_printf(MSG_ERROR, "TLS: Unsupported Phase2 EAP "
"method '%s'", start);
} else {
num_methods++;
_methods = os_realloc(methods,
num_methods * sizeof(*methods));
if (_methods == NULL) {
os_free(methods);
os_free(buf);
return -1;
}
methods = _methods;
methods[num_methods - 1].vendor = vendor;
methods[num_methods - 1].method = method;
}
start = pos;
}
os_free(buf);
get_defaults:
if (methods == NULL)
methods = eap_get_phase2_types(config, &num_methods);
if (methods == NULL) {
wpa_printf(MSG_ERROR, "TLS: No Phase2 EAP methods available");
return -1;
}
wpa_hexdump(MSG_DEBUG, "TLS: Phase2 EAP types",
(u8 *) methods,
num_methods * sizeof(struct eap_method_type));
*types = methods;
*num_types = num_methods;
return 0;
}
/******************************************************************************
* FunctionName : user_platform_timer_first_start
* Description : calculate the wait time of each timer
* Parameters : count -- The number of timers given by server
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_platform_timer_first_start(uint16 count)
{
int i = 0;
struct esp_platform_wait_timer_param timer_wait_param[100] = {0};
ESP_DBG("current timestamp= %ds\n", timestamp);
timestamp = timestamp + min_wait_second;
for (i = 0 ; i < count ; i++) {
char *str = timer_splits[i];
if (indexof(str, "f", 0) == 0) {
char *fixed_wait[2];
ESP_DBG("timer is fixed mode\n");
split(str, "=", fixed_wait);
os_memcpy(timer_wait_param[i].wait_time_param, fixed_wait[0] + 1, os_strlen(fixed_wait[0]) - 1);
os_memcpy(timer_wait_param[i].wait_action, fixed_wait[1], os_strlen(fixed_wait[1]));
timer_wait_param[i].wait_time_second = atoi(timer_wait_param[i].wait_time_param) - timestamp;
os_free(fixed_wait[0]);
os_free(fixed_wait[1]);
}
else if (indexof(str, "l", 0) == 0) {
char *loop_wait[2];
ESP_DBG("timer is loop mode\n");
split(str, "=", loop_wait);
os_memcpy(timer_wait_param[i].wait_time_param, loop_wait[0] + 1, os_strlen(loop_wait[0]) - 1);
os_memcpy(timer_wait_param[i].wait_action, loop_wait[1], os_strlen(loop_wait[1]));
timer_wait_param[i].wait_time_second = atoi(timer_wait_param[i].wait_time_param) - (timestamp % atoi(timer_wait_param[i].wait_time_param));
os_free(loop_wait[0]);
os_free(loop_wait[1]);
} else if (indexof(str, "w", 0) == 0) {
char *week_wait[2];
int monday_wait_time = 0;
ESP_DBG("timer is weekend mode\n");
split(str, "=", week_wait);
os_memcpy(timer_wait_param[i].wait_time_param, week_wait[0] + 1, os_strlen(week_wait[0]) - 1);
os_memcpy(timer_wait_param[i].wait_action, week_wait[1], os_strlen(week_wait[1]));
monday_wait_time = (timestamp - 1388937600) % (7 * 24 * 3600);
ESP_DBG("monday_wait_time == %d", monday_wait_time);
if (atoi(timer_wait_param[i].wait_time_param) > monday_wait_time) {
timer_wait_param[i].wait_time_second = atoi(timer_wait_param[i].wait_time_param) - monday_wait_time;
} else {
timer_wait_param[i].wait_time_second = 7 * 24 * 3600 - monday_wait_time + atoi(timer_wait_param[i].wait_time_param);
}
os_free(week_wait[0]);
os_free(week_wait[1]);
}
}
esp_platform_find_min_time(timer_wait_param, count);
if(min_wait_second == 0) {
return;
}
esp_platform_timer_action(timer_wait_param, count);
}
void MDNSResponder::_reply(uint8_t replyMask, char * service, char *proto, uint16_t port) {
int i;
if (replyMask == 0) return;
#ifdef MDNS_DEBUG_TX
Serial.printf("TX: mask:%01X, service:%s, proto:%s, port:%u\n", replyMask, service, proto, port);
#endif
String instanceName = _instanceName;
size_t instanceNameLen = instanceName.length();
String hostName = _hostName;
size_t hostNameLen = hostName.length();
char underscore[] = "_";
// build service name with _
char serviceName[os_strlen(service) + 2];
os_strcpy(serviceName, underscore);
os_strcat(serviceName, service);
size_t serviceNameLen = os_strlen(serviceName);
//build proto name with _
char protoName[5];
os_strcpy(protoName, underscore);
os_strcat(protoName, proto);
size_t protoNameLen = 4;
//local string
char localName[] = "local";
size_t localNameLen = 5;
//terminator
char terminator[] = "\0";
uint8_t answerCount = 0;
for (i = 0; i<4; i++) {
if (replyMask & (1 << i)) answerCount++;
}
//Write the header
_conn->flush();
uint8_t head[12] = {
0x00, 0x00, //ID = 0
0x84, 0x00, //Flags = response + authoritative answer
0x00, 0x00, //Question count
0x00, answerCount, //Answer count
0x00, 0x00, //Name server records
0x00, 0x00, //Additional records
};
_conn->append(reinterpret_cast<const char*>(head), 12);
// PTR Response
if (replyMask & 0x8) {
// Send the Name field (ie. "_http._tcp.local")
_conn->append(reinterpret_cast<const char*>(&serviceNameLen), 1); // lenght of "_http"
_conn->append(reinterpret_cast<const char*>(serviceName), serviceNameLen); // "_http"
_conn->append(reinterpret_cast<const char*>(&protoNameLen), 1); // lenght of "_tcp"
_conn->append(reinterpret_cast<const char*>(protoName), protoNameLen); // "_tcp"
_conn->append(reinterpret_cast<const char*>(&localNameLen), 1); // lenght "local"
_conn->append(reinterpret_cast<const char*>(localName), localNameLen); // "local"
_conn->append(reinterpret_cast<const char*>(&terminator), 1); // terminator
//Send the type, class, ttl and rdata length
uint8_t ptrDataLen = instanceNameLen + serviceNameLen + protoNameLen + localNameLen + 5; // 5 is four label sizes and the terminator
uint8_t ptrAttrs[10] = {
0x00, 0x0c, //PTR record query
0x00, 0x01, //Class IN
0x00, 0x00, 0x11, 0x94, //TTL 4500
0x00, ptrDataLen, //RData length
};
_conn->append(reinterpret_cast<const char*>(ptrAttrs), 10);
//Send the RData (ie. "My IOT device._http._tcp.local")
_conn->append(reinterpret_cast<const char*>(&instanceNameLen), 1); // lenght of "My IOT device"
_conn->append(reinterpret_cast<const char*>(instanceName.c_str()), instanceNameLen);// "My IOT device"
_conn->append(reinterpret_cast<const char*>(&serviceNameLen), 1); // lenght of "_http"
_conn->append(reinterpret_cast<const char*>(serviceName), serviceNameLen); // "_http"
_conn->append(reinterpret_cast<const char*>(&protoNameLen), 1); // lenght of "_tcp"
_conn->append(reinterpret_cast<const char*>(protoName), protoNameLen); // "_tcp"
_conn->append(reinterpret_cast<const char*>(&localNameLen), 1); // lenght "local"
_conn->append(reinterpret_cast<const char*>(localName), localNameLen); // "local"
_conn->append(reinterpret_cast<const char*>(&terminator), 1); // terminator
}
//TXT Responce
if (replyMask & 0x4) {
//Send the name field (ie. "My IOT device._http._tcp.local")
_conn->append(reinterpret_cast<const char*>(&instanceNameLen), 1); // lenght of "My IOT device"
_conn->append(reinterpret_cast<const char*>(instanceName.c_str()), instanceNameLen);// "My IOT device"
_conn->append(reinterpret_cast<const char*>(&serviceNameLen), 1); // lenght of "_http"
_conn->append(reinterpret_cast<const char*>(serviceName), serviceNameLen); // "_http"
_conn->append(reinterpret_cast<const char*>(&protoNameLen), 1); // lenght of "_tcp"
_conn->append(reinterpret_cast<const char*>(protoName), protoNameLen); // "_tcp"
_conn->append(reinterpret_cast<const char*>(&localNameLen), 1); // lenght "local"
_conn->append(reinterpret_cast<const char*>(localName), localNameLen); // "local"
_conn->append(reinterpret_cast<const char*>(&terminator), 1); // terminator
//Send the type, class, ttl and rdata length
uint8_t txtDataLen = _getServiceTxtLen(service, proto);
uint8_t txtAttrs[10] = {
0x00, 0x10, //TXT record query
0x00, 0x01, //Class IN
0x00, 0x00, 0x11, 0x94, //TTL 4500
0x00, txtDataLen, //RData length
};
_conn->append(reinterpret_cast<const char*>(txtAttrs), 10);
//Send the RData
MDNSTxt * txtPtr = _getServiceTxt(service, proto);
while (txtPtr != 0) {
uint8_t txtLen = txtPtr->_txt.length();
_conn->append(reinterpret_cast<const char*>(&txtLen), 1); // lenght of txt
_conn->append(reinterpret_cast<const char*>(txtPtr->_txt.c_str()), txtLen);// the txt
txtPtr = txtPtr->_next;
}
}
//SRV Responce
if (replyMask & 0x2) {
//Send the name field (ie. "My IOT device._http._tcp.local")
_conn->append(reinterpret_cast<const char*>(&instanceNameLen), 1); // lenght of "My IOT device"
_conn->append(reinterpret_cast<const char*>(instanceName.c_str()), instanceNameLen);// "My IOT device"
_conn->append(reinterpret_cast<const char*>(&serviceNameLen), 1); // lenght of "_http"
_conn->append(reinterpret_cast<const char*>(serviceName), serviceNameLen); // "_http"
_conn->append(reinterpret_cast<const char*>(&protoNameLen), 1); // lenght of "_tcp"
_conn->append(reinterpret_cast<const char*>(protoName), protoNameLen); // "_tcp"
_conn->append(reinterpret_cast<const char*>(&localNameLen), 1); // lenght "local"
_conn->append(reinterpret_cast<const char*>(localName), localNameLen); // "local"
_conn->append(reinterpret_cast<const char*>(&terminator), 1); // terminator
//Send the type, class, ttl, rdata length, priority and weight
uint8_t srvDataSize = hostNameLen + localNameLen + 3; // 3 is 2 lable size bytes and the terminator
srvDataSize += 6; // Size of Priority, weight and port
uint8_t srvAttrs[10] = {
0x00, 0x21, //Type SRV
0x80, 0x01, //Class IN, with cache flush
0x00, 0x00, 0x00, 0x78, //TTL 120
0x00, srvDataSize, //RData length
};
_conn->append(reinterpret_cast<const char*>(srvAttrs), 10);
//Send the RData Priority weight and port
uint8_t srvRData[6] = {
0x00, 0x00, //Priority 0
0x00, 0x00, //Weight 0
(uint8_t)((port >> 8) & 0xFF), (uint8_t)(port & 0xFF)
};
_conn->append(reinterpret_cast<const char*>(srvRData), 6);
//Send the RData (ie. "esp8266.local")
_conn->append(reinterpret_cast<const char*>(&hostNameLen), 1); // lenght of "esp8266"
_conn->append(reinterpret_cast<const char*>(hostName.c_str()), hostNameLen);// "esp8266"
_conn->append(reinterpret_cast<const char*>(&localNameLen), 1); // lenght "local"
_conn->append(reinterpret_cast<const char*>(localName), localNameLen); // "local"
_conn->append(reinterpret_cast<const char*>(&terminator), 1); // terminator
}
// A Response
if (replyMask & 0x1) {
//Send the RData (ie. "esp8266.local")
_conn->append(reinterpret_cast<const char*>(&hostNameLen), 1); // lenght of "esp8266"
_conn->append(reinterpret_cast<const char*>(hostName.c_str()), hostNameLen);// "esp8266"
_conn->append(reinterpret_cast<const char*>(&localNameLen), 1); // lenght "local"
_conn->append(reinterpret_cast<const char*>(localName), localNameLen); // "local"
_conn->append(reinterpret_cast<const char*>(&terminator), 1); // terminator
uint32_t ip = _getOurIp();
uint8_t aaaAttrs[10] = {
0x00, 0x01, //TYPE A
0x80, 0x01, //Class IN, with cache flush
0x00, 0x00, 0x00, 0x78, //TTL 120
0x00, 0x04, //DATA LEN
};
_conn->append(reinterpret_cast<const char*>(aaaAttrs), 10);
// Send RData
uint8_t aaaRData[4] = {
(uint8_t)(ip & 0xFF), //IP first octet
(uint8_t)((ip >> 8) & 0xFF), //IP second octet
(uint8_t)((ip >> 16) & 0xFF), //IP third octet
(uint8_t)((ip >> 24) & 0xFF) //IP fourth octet
};
_conn->append(reinterpret_cast<const char*>(aaaRData), 4);
}
static int hostapd_config_read_wpa_psk(const char *fname,
struct hostapd_ssid *ssid)
{
FILE *f;
char buf[128], *pos;
int line = 0, ret = 0, len, ok;
u8 addr[ETH_ALEN];
struct hostapd_wpa_psk *psk;
if (!fname)
return 0;
f = fopen(fname, "r");
if (!f) {
wpa_printf(MSG_ERROR, "WPA PSK file '%s' not found.", fname);
return -1;
}
while (fgets(buf, sizeof(buf), f)) {
line++;
if (buf[0] == '#')
continue;
pos = buf;
while (*pos != '\0') {
if (*pos == '\n') {
*pos = '\0';
break;
}
pos++;
}
if (buf[0] == '\0')
continue;
if (hwaddr_aton(buf, addr)) {
wpa_printf(MSG_ERROR, "Invalid MAC address '%s' on "
"line %d in '%s'", buf, line, fname);
ret = -1;
break;
}
psk = os_zalloc(sizeof(*psk));
if (psk == NULL) {
wpa_printf(MSG_ERROR, "WPA PSK allocation failed");
ret = -1;
break;
}
if (is_zero_ether_addr(addr))
psk->group = 1;
else
os_memcpy(psk->addr, addr, ETH_ALEN);
pos = buf + 17;
if (*pos == '\0') {
wpa_printf(MSG_ERROR, "No PSK on line %d in '%s'",
line, fname);
os_free(psk);
ret = -1;
break;
}
pos++;
ok = 0;
len = os_strlen(pos);
if (len == 64 && hexstr2bin(pos, psk->psk, PMK_LEN) == 0)
ok = 1;
else if (len >= 8 && len < 64) {
pbkdf2_sha1(pos, ssid->ssid, ssid->ssid_len,
4096, psk->psk, PMK_LEN);
ok = 1;
}
if (!ok) {
wpa_printf(MSG_ERROR, "Invalid PSK '%s' on line %d in "
"'%s'", pos, line, fname);
os_free(psk);
ret = -1;
break;
}
psk->next = ssid->wpa_psk;
ssid->wpa_psk = psk;
}
fclose(f);
return ret;
}
int MDNSResponder::queryService(char *service, char *proto) {
#ifdef MDNS_DEBUG_TX
Serial.printf("queryService %s %s\n", service, proto);
#endif
if (_query != 0) {
os_free(_query);
_query = 0;
}
_query = (struct MDNSQuery*)(os_malloc(sizeof(struct MDNSQuery)));
os_strcpy(_query->_service, service);
os_strcpy(_query->_proto, proto);
_newQuery = true;
char underscore[] = "_";
// build service name with _
char serviceName[os_strlen(service) + 2];
os_strcpy(serviceName, underscore);
os_strcat(serviceName, service);
size_t serviceNameLen = os_strlen(serviceName);
//build proto name with _
char protoName[5];
os_strcpy(protoName, underscore);
os_strcat(protoName, proto);
size_t protoNameLen = 4;
//local string
char localName[] = "local";
size_t localNameLen = 5;
//terminator
char terminator[] = "\0";
// Only supports sending one PTR query
uint8_t questionCount = 1;
// Write the header
_conn->flush();
uint8_t head[12] = {
0x00, 0x00, //ID = 0
0x00, 0x00, //Flags = response + authoritative answer
0x00, questionCount, //Question count
0x00, 0x00, //Answer count
0x00, 0x00, //Name server records
0x00, 0x00 //Additional records
};
_conn->append(reinterpret_cast<const char*>(head), 12);
// Only supports sending one PTR query
// Send the Name field (eg. "_http._tcp.local")
_conn->append(reinterpret_cast<const char*>(&serviceNameLen), 1); // lenght of "_" + service
_conn->append(reinterpret_cast<const char*>(serviceName), serviceNameLen); // "_" + service
_conn->append(reinterpret_cast<const char*>(&protoNameLen), 1); // lenght of "_" + proto
_conn->append(reinterpret_cast<const char*>(protoName), protoNameLen); // "_" + proto
_conn->append(reinterpret_cast<const char*>(&localNameLen), 1); // lenght of "local"
_conn->append(reinterpret_cast<const char*>(localName), localNameLen); // "local"
_conn->append(reinterpret_cast<const char*>(&terminator), 1); // terminator
//Send the type and class
uint8_t ptrAttrs[4] = {
0x00, 0x0c, //PTR record query
0x00, 0x01 //Class IN
};
_conn->append(reinterpret_cast<const char*>(ptrAttrs), 4);
_waitingForAnswers = true;
_conn->send();
#ifdef MDNS_DEBUG_TX
Serial.println("Waiting for answers..");
#endif
delay(1000);
_waitingForAnswers = false;
return _getNumAnswers();
}
static void eap_sim_db_aka_resp_auth(struct eap_sim_db_data *data,
const char *imsi, char *buf)
{
char *start, *end;
struct eap_sim_db_pending *entry;
/*
* AKA-RESP-AUTH <IMSI> <RAND> <AUTN> <IK> <CK> <RES>
* AKA-RESP-AUTH <IMSI> FAILURE
* (IMSI = ASCII string, RAND/AUTN/IK/CK/RES = hex string)
*/
entry = eap_sim_db_get_pending(data, (u8 *) imsi, os_strlen(imsi), 1);
if (entry == NULL) {
asd_printf(ASD_DEFAULT,MSG_DEBUG, "EAP-SIM DB: No pending entry for the "
"received message found");
return;
}
start = buf;
if (os_strncmp(start, "FAILURE", 7) == 0) {
asd_printf(ASD_DEFAULT,MSG_DEBUG, "EAP-SIM DB: External server reported "
"failure");
entry->state = FAILURE;
eap_sim_db_add_pending(data, entry);
data->get_complete_cb(data->ctx, entry->cb_session_ctx);
return;
}
end = os_strchr(start, ' ');
if (end == NULL)
goto parse_fail;
*end = '\0';
if (hexstr2bin(start, entry->u.aka.rand, EAP_AKA_RAND_LEN))
goto parse_fail;
start = end + 1;
end = os_strchr(start, ' ');
if (end == NULL)
goto parse_fail;
*end = '\0';
if (hexstr2bin(start, entry->u.aka.autn, EAP_AKA_AUTN_LEN))
goto parse_fail;
start = end + 1;
end = os_strchr(start, ' ');
if (end == NULL)
goto parse_fail;
*end = '\0';
if (hexstr2bin(start, entry->u.aka.ik, EAP_AKA_IK_LEN))
goto parse_fail;
start = end + 1;
end = os_strchr(start, ' ');
if (end == NULL)
goto parse_fail;
*end = '\0';
if (hexstr2bin(start, entry->u.aka.ck, EAP_AKA_CK_LEN))
goto parse_fail;
start = end + 1;
end = os_strchr(start, ' ');
if (end)
*end = '\0';
else {
end = start;
while (*end)
end++;
}
entry->u.aka.res_len = (end - start) / 2;
if (entry->u.aka.res_len > EAP_AKA_RES_MAX_LEN) {
asd_printf(ASD_DEFAULT,MSG_DEBUG, "EAP-SIM DB: Too long RES");
entry->u.aka.res_len = 0;
goto parse_fail;
}
if (hexstr2bin(start, entry->u.aka.res, entry->u.aka.res_len))
goto parse_fail;
entry->state = SUCCESS;
asd_printf(ASD_DEFAULT,MSG_DEBUG, "EAP-SIM DB: Authentication data parsed "
"successfully - callback");
eap_sim_db_add_pending(data, entry);
data->get_complete_cb(data->ctx, entry->cb_session_ctx);
return;
parse_fail:
asd_printf(ASD_DEFAULT,MSG_DEBUG, "EAP-SIM DB: Failed to parse response string");
os_free(entry);
}
static void eap_sim_db_sim_resp_auth(struct eap_sim_db_data *data,
const char *imsi, char *buf)
{
char *start, *end, *pos;
struct eap_sim_db_pending *entry;
int num_chal;
/*
* SIM-RESP-AUTH <IMSI> Kc(i):SRES(i):RAND(i) ...
* SIM-RESP-AUTH <IMSI> FAILURE
* (IMSI = ASCII string, Kc/SRES/RAND = hex string)
*/
entry = eap_sim_db_get_pending(data, (u8 *) imsi, os_strlen(imsi), 0);
if (entry == NULL) {
asd_printf(ASD_DEFAULT,MSG_DEBUG, "EAP-SIM DB: No pending entry for the "
"received message found");
return;
}
start = buf;
if (os_strncmp(start, "FAILURE", 7) == 0) {
asd_printf(ASD_DEFAULT,MSG_DEBUG, "EAP-SIM DB: External server reported "
"failure");
entry->state = FAILURE;
eap_sim_db_add_pending(data, entry);
data->get_complete_cb(data->ctx, entry->cb_session_ctx);
return;
}
num_chal = 0;
while (num_chal < EAP_SIM_MAX_CHAL) {
end = os_strchr(start, ' ');
if (end)
*end = '\0';
pos = os_strchr(start, ':');
if (pos == NULL)
goto parse_fail;
*pos = '\0';
if (hexstr2bin(start, entry->u.sim.kc[num_chal],
EAP_SIM_KC_LEN))
goto parse_fail;
start = pos + 1;
pos = os_strchr(start, ':');
if (pos == NULL)
goto parse_fail;
*pos = '\0';
if (hexstr2bin(start, entry->u.sim.sres[num_chal],
EAP_SIM_SRES_LEN))
goto parse_fail;
start = pos + 1;
if (hexstr2bin(start, entry->u.sim.rand[num_chal],
GSM_RAND_LEN))
goto parse_fail;
num_chal++;
if (end == NULL)
break;
else
start = end + 1;
}
entry->u.sim.num_chal = num_chal;
entry->state = SUCCESS;
asd_printf(ASD_DEFAULT,MSG_DEBUG, "EAP-SIM DB: Authentication data parsed "
"successfully - callback");
eap_sim_db_add_pending(data, entry);
data->get_complete_cb(data->ctx, entry->cb_session_ctx);
return;
parse_fail:
asd_printf(ASD_DEFAULT,MSG_DEBUG, "EAP-SIM DB: Failed to parse response string");
os_free(entry);
}
/**
* eap_sim_db_get_aka_auth - Get AKA authentication values
* @data: Private data pointer from eap_sim_db_init()
* @username: Permanent username (prefix | IMSI)
* @_rand: Buffer for RAND value
* @autn: Buffer for AUTN value
* @ik: Buffer for IK value
* @ck: Buffer for CK value
* @res: Buffer for RES value
* @res_len: Buffer for RES length
* @cb_session_ctx: Session callback context for get_complete_cb()
* Returns: 0 on success, -1 (EAP_SIM_DB_FAILURE) on error (e.g., user not
* found), or -2 (EAP_SIM_DB_PENDING) if results are not yet available. In this
* case, the callback function registered with eap_sim_db_init() will be
* called once the results become available.
*
* When using an external server for AKA authentication, this function can
* always start a request and return EAP_SIM_DB_PENDING immediately if
* authentication triplets are not available. Once the authentication data are
* received, callback function registered with eap_sim_db_init() is called to
* notify EAP state machine to reprocess the message. This
* eap_sim_db_get_aka_auth() function will then be called again and the newly
* received triplets will then be given to the caller.
*/
int eap_sim_db_get_aka_auth(struct eap_sim_db_data *data, const char *username,
u8 *_rand, u8 *autn, u8 *ik, u8 *ck,
u8 *res, size_t *res_len, void *cb_session_ctx)
{
struct eap_sim_db_pending *entry;
int len;
char msg[40];
const char *imsi;
size_t imsi_len;
if (username == NULL ||
(username[0] != EAP_AKA_PERMANENT_PREFIX &&
username[0] != EAP_AKA_PRIME_PERMANENT_PREFIX) ||
username[1] == '\0' || os_strlen(username) > sizeof(entry->imsi)) {
wpa_printf(MSG_DEBUG, "EAP-SIM DB: unexpected username '%s'",
username);
return EAP_SIM_DB_FAILURE;
}
imsi = username + 1;
wpa_printf(MSG_DEBUG, "EAP-SIM DB: Get AKA auth for IMSI '%s'",
imsi);
entry = eap_sim_db_get_pending(data, imsi, 1);
if (entry) {
if (entry->state == FAILURE) {
os_free(entry);
wpa_printf(MSG_DEBUG, "EAP-SIM DB: Failure");
return EAP_SIM_DB_FAILURE;
}
if (entry->state == PENDING) {
eap_sim_db_add_pending(data, entry);
wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending");
return EAP_SIM_DB_PENDING;
}
wpa_printf(MSG_DEBUG, "EAP-SIM DB: Returning successfully "
"received authentication data");
os_memcpy(_rand, entry->u.aka.rand, EAP_AKA_RAND_LEN);
os_memcpy(autn, entry->u.aka.autn, EAP_AKA_AUTN_LEN);
os_memcpy(ik, entry->u.aka.ik, EAP_AKA_IK_LEN);
os_memcpy(ck, entry->u.aka.ck, EAP_AKA_CK_LEN);
os_memcpy(res, entry->u.aka.res, EAP_AKA_RES_MAX_LEN);
*res_len = entry->u.aka.res_len;
os_free(entry);
return 0;
}
if (data->sock < 0) {
if (eap_sim_db_open_socket(data) < 0)
return EAP_SIM_DB_FAILURE;
}
imsi_len = os_strlen(imsi);
len = os_snprintf(msg, sizeof(msg), "AKA-REQ-AUTH ");
if (len < 0 || len + imsi_len >= sizeof(msg))
return EAP_SIM_DB_FAILURE;
os_memcpy(msg + len, imsi, imsi_len);
len += imsi_len;
wpa_printf(MSG_DEBUG, "EAP-SIM DB: requesting AKA authentication "
"data for IMSI '%s'", imsi);
if (eap_sim_db_send(data, msg, len) < 0)
return EAP_SIM_DB_FAILURE;
entry = os_zalloc(sizeof(*entry));
if (entry == NULL)
return EAP_SIM_DB_FAILURE;
os_get_time(&entry->timestamp);
entry->aka = 1;
os_strlcpy(entry->imsi, imsi, sizeof(entry->imsi));
entry->cb_session_ctx = cb_session_ctx;
entry->state = PENDING;
eap_sim_db_add_pending(data, entry);
eap_sim_db_expire_pending(data);
return EAP_SIM_DB_PENDING;
}
/******************************************************************************
* FunctionName : user_platform_timer_start
* Description : Processing the message about timer from the server
* Parameters : timer_wait_param -- The received data from the server
* count -- the espconn used to connetion with the host
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
esp_platform_timer_action(struct esp_platform_wait_timer_param *timer_wait_param, uint16 count)
{
uint16 i = 0;
uint16 action_number;
struct wait_param pwait_action = {0};
pwait_action.count = count;
action_number = 0;
for (i = 0; i < count ; i++) {
if (timer_wait_param[i].wait_time_second == min_wait_second) {
os_memcpy(pwait_action.action[action_number], timer_wait_param[i].wait_action, os_strlen(timer_wait_param[i].wait_action));
ESP_DBG("*****%s*****\n", timer_wait_param[i].wait_action);
action_number++;
}
}
pwait_action.action_number = action_number;
pwait_action.min_time_backup = min_wait_second;
user_esp_platform_wait_time_overflow_check(&pwait_action);
}
/**
* eap_sim_db_get_gsm_triplets - Get GSM triplets
* @data: Private data pointer from eap_sim_db_init()
* @username: Permanent username (prefix | IMSI)
* @max_chal: Maximum number of triplets
* @_rand: Buffer for RAND values
* @kc: Buffer for Kc values
* @sres: Buffer for SRES values
* @cb_session_ctx: Session callback context for get_complete_cb()
* Returns: Number of triplets received (has to be less than or equal to
* max_chal), -1 (EAP_SIM_DB_FAILURE) on error (e.g., user not found), or
* -2 (EAP_SIM_DB_PENDING) if results are not yet available. In this case, the
* callback function registered with eap_sim_db_init() will be called once the
* results become available.
*
* When using an external server for GSM triplets, this function can always
* start a request and return EAP_SIM_DB_PENDING immediately if authentication
* triplets are not available. Once the triplets are received, callback
* function registered with eap_sim_db_init() is called to notify EAP state
* machine to reprocess the message. This eap_sim_db_get_gsm_triplets()
* function will then be called again and the newly received triplets will then
* be given to the caller.
*/
int eap_sim_db_get_gsm_triplets(struct eap_sim_db_data *data,
const char *username, int max_chal,
u8 *_rand, u8 *kc, u8 *sres,
void *cb_session_ctx)
{
struct eap_sim_db_pending *entry;
int len, ret;
char msg[40];
const char *imsi;
size_t imsi_len;
if (username == NULL || username[0] != EAP_SIM_PERMANENT_PREFIX ||
username[1] == '\0' || os_strlen(username) > sizeof(entry->imsi)) {
wpa_printf(MSG_DEBUG, "EAP-SIM DB: unexpected username '%s'",
username);
return EAP_SIM_DB_FAILURE;
}
imsi = username + 1;
wpa_printf(MSG_DEBUG, "EAP-SIM DB: Get GSM triplets for IMSI '%s'",
imsi);
entry = eap_sim_db_get_pending(data, imsi, 0);
if (entry) {
int num_chal;
if (entry->state == FAILURE) {
wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending entry -> "
"failure");
os_free(entry);
return EAP_SIM_DB_FAILURE;
}
if (entry->state == PENDING) {
wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending entry -> "
"still pending");
eap_sim_db_add_pending(data, entry);
return EAP_SIM_DB_PENDING;
}
wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending entry -> "
"%d challenges", entry->u.sim.num_chal);
num_chal = entry->u.sim.num_chal;
if (num_chal > max_chal)
num_chal = max_chal;
os_memcpy(_rand, entry->u.sim.rand, num_chal * GSM_RAND_LEN);
os_memcpy(sres, entry->u.sim.sres,
num_chal * EAP_SIM_SRES_LEN);
os_memcpy(kc, entry->u.sim.kc, num_chal * EAP_SIM_KC_LEN);
os_free(entry);
return num_chal;
}
if (data->sock < 0) {
if (eap_sim_db_open_socket(data) < 0)
return EAP_SIM_DB_FAILURE;
}
imsi_len = os_strlen(imsi);
len = os_snprintf(msg, sizeof(msg), "SIM-REQ-AUTH ");
if (len < 0 || len + imsi_len >= sizeof(msg))
return EAP_SIM_DB_FAILURE;
os_memcpy(msg + len, imsi, imsi_len);
len += imsi_len;
ret = os_snprintf(msg + len, sizeof(msg) - len, " %d", max_chal);
if (ret < 0 || (size_t) ret >= sizeof(msg) - len)
return EAP_SIM_DB_FAILURE;
len += ret;
wpa_printf(MSG_DEBUG, "EAP-SIM DB: requesting SIM authentication "
"data for IMSI '%s'", imsi);
if (eap_sim_db_send(data, msg, len) < 0)
return EAP_SIM_DB_FAILURE;
entry = os_zalloc(sizeof(*entry));
if (entry == NULL)
return EAP_SIM_DB_FAILURE;
os_get_time(&entry->timestamp);
os_strlcpy(entry->imsi, imsi, sizeof(entry->imsi));
entry->cb_session_ctx = cb_session_ctx;
entry->state = PENDING;
eap_sim_db_add_pending(data, entry);
eap_sim_db_expire_pending(data);
return EAP_SIM_DB_PENDING;
}
LOCAL ICACHE_FLASH_ATTR
char *save_data(char *precv, uint16 length) {
LOCAL char *precvbuffer;
LOCAL uint32 dat_sumlength = 0;
LOCAL uint32 totallength = 0;
bool flag = false;
char length_buf[10] = {0};
char *ptemp = NULL;
char *pdata = NULL;
uint16 headlength = 0;
ptemp = (char *)os_strstr(precv, "\r\n\r\n");
if (ptemp != NULL) {
length -= ptemp - precv;
length -= 4;
totallength += length;
headlength = ptemp - precv + 4;
pdata = (char *)os_strstr(precv, "Content-Length: ");
if (pdata != NULL) {
pdata += 16;
precvbuffer = (char *)os_strstr(pdata, "\r\n");
if (precvbuffer != NULL) {
os_memcpy(length_buf, pdata, precvbuffer - pdata);
dat_sumlength = atoi(length_buf);
}
} else {
if (totallength != 0x00) {
totallength = 0;
dat_sumlength = 0;
return NULL;
}
}
if ((dat_sumlength + headlength) >= 1024) {
precvbuffer = (char *)os_zalloc(headlength + 1);
os_memcpy(precvbuffer, precv, headlength + 1);
} else {
precvbuffer = (char *)os_zalloc(dat_sumlength + headlength + 1);
os_memcpy(precvbuffer, precv, os_strlen(precv));
}
} else {
if (precvbuffer != NULL) {
totallength += length;
os_memcpy(precvbuffer + os_strlen(precvbuffer), precv, length);
} else {
totallength = 0;
dat_sumlength = 0;
return NULL;
}
}
if (totallength == dat_sumlength) {
totallength = 0;
dat_sumlength = 0;
return precvbuffer;
} else {
return NULL;
}
}
static VOID IpcEvent_SendMessageToChild(IpcEvent_t* pIpcEvent, PS8 msg)
{
write(pIpcEvent->pipe_to_child, msg, os_strlen(msg));
}
static int wpa_driver_privsep_set_param(void *priv, const char *param)
{
struct wpa_driver_privsep_data *drv = priv;
const char *pos;
char *own_dir, *priv_dir;
static unsigned int counter = 0;
size_t len;
struct sockaddr_un addr;
wpa_printf(MSG_DEBUG, "%s: param='%s'", __func__, param);
if (param == NULL)
pos = NULL;
else
pos = os_strstr(param, "own_dir=");
if (pos) {
char *end;
own_dir = os_strdup(pos + 8);
if (own_dir == NULL)
return -1;
end = os_strchr(own_dir, ' ');
if (end)
*end = '\0';
} else {
own_dir = os_strdup("/tmp");
if (own_dir == NULL)
return -1;
}
if (param == NULL)
pos = NULL;
else
pos = os_strstr(param, "priv_dir=");
if (pos) {
char *end;
priv_dir = os_strdup(pos + 9);
if (priv_dir == NULL) {
os_free(own_dir);
return -1;
}
end = os_strchr(priv_dir, ' ');
if (end)
*end = '\0';
} else {
priv_dir = os_strdup("/var/run/wpa_priv");
if (priv_dir == NULL) {
os_free(own_dir);
return -1;
}
}
len = os_strlen(own_dir) + 50;
drv->own_socket_path = os_malloc(len);
if (drv->own_socket_path == NULL) {
os_free(priv_dir);
os_free(own_dir);
return -1;
}
os_snprintf(drv->own_socket_path, len, "%s/wpa_privsep-%d-%d",
own_dir, getpid(), counter++);
len = os_strlen(own_dir) + 50;
drv->own_cmd_path = os_malloc(len);
if (drv->own_cmd_path == NULL) {
os_free(drv->own_socket_path);
drv->own_socket_path = NULL;
os_free(priv_dir);
os_free(own_dir);
return -1;
}
os_snprintf(drv->own_cmd_path, len, "%s/wpa_privsep-%d-%d",
own_dir, getpid(), counter++);
os_free(own_dir);
drv->priv_addr.sun_family = AF_UNIX;
os_snprintf(drv->priv_addr.sun_path, sizeof(drv->priv_addr.sun_path),
"%s/%s", priv_dir, drv->ifname);
os_free(priv_dir);
drv->priv_socket = socket(PF_UNIX, SOCK_DGRAM, 0);
if (drv->priv_socket < 0) {
perror("socket(PF_UNIX)");
os_free(drv->own_socket_path);
drv->own_socket_path = NULL;
return -1;
}
os_memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
os_strlcpy(addr.sun_path, drv->own_socket_path, sizeof(addr.sun_path));
if (bind(drv->priv_socket, (struct sockaddr *) &addr, sizeof(addr)) <
0) {
perror("bind(PF_UNIX)");
close(drv->priv_socket);
drv->priv_socket = -1;
unlink(drv->own_socket_path);
os_free(drv->own_socket_path);
drv->own_socket_path = NULL;
return -1;
}
eloop_register_read_sock(drv->priv_socket, wpa_driver_privsep_receive,
drv, NULL);
drv->cmd_socket = socket(PF_UNIX, SOCK_DGRAM, 0);
if (drv->cmd_socket < 0) {
perror("socket(PF_UNIX)");
os_free(drv->own_cmd_path);
drv->own_cmd_path = NULL;
return -1;
}
os_memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
os_strlcpy(addr.sun_path, drv->own_cmd_path, sizeof(addr.sun_path));
if (bind(drv->cmd_socket, (struct sockaddr *) &addr, sizeof(addr)) < 0)
{
perror("bind(PF_UNIX)");
close(drv->cmd_socket);
drv->cmd_socket = -1;
unlink(drv->own_cmd_path);
os_free(drv->own_cmd_path);
drv->own_cmd_path = NULL;
return -1;
}
if (wpa_priv_reg_cmd(drv, PRIVSEP_CMD_REGISTER) < 0) {
wpa_printf(MSG_ERROR, "Failed to register with wpa_priv");
return -1;
}
return 0;
}
static struct wpa_priv_interface *
wpa_priv_interface_init(void *ctx, const char *dir, const char *params)
{
struct wpa_priv_interface *iface;
char *pos;
size_t len;
struct sockaddr_un addr;
int i;
pos = os_strchr(params, ':');
if (pos == NULL)
return NULL;
iface = os_zalloc(sizeof(*iface));
if (iface == NULL)
return NULL;
iface->fd = -1;
iface->ctx = ctx;
len = pos - params;
iface->driver_name = dup_binstr(params, len);
if (iface->driver_name == NULL) {
wpa_priv_interface_deinit(iface);
return NULL;
}
for (i = 0; wpa_drivers[i]; i++) {
if (os_strcmp(iface->driver_name,
wpa_drivers[i]->name) == 0) {
iface->driver = wpa_drivers[i];
break;
}
}
if (iface->driver == NULL) {
wpa_printf(MSG_ERROR, "Unsupported driver '%s'",
iface->driver_name);
wpa_priv_interface_deinit(iface);
return NULL;
}
pos++;
iface->ifname = os_strdup(pos);
if (iface->ifname == NULL) {
wpa_priv_interface_deinit(iface);
return NULL;
}
len = os_strlen(dir) + 1 + os_strlen(iface->ifname);
iface->sock_name = os_malloc(len + 1);
if (iface->sock_name == NULL) {
wpa_priv_interface_deinit(iface);
return NULL;
}
os_snprintf(iface->sock_name, len + 1, "%s/%s", dir, iface->ifname);
if (os_strlen(iface->sock_name) >= sizeof(addr.sun_path)) {
wpa_priv_interface_deinit(iface);
return NULL;
}
iface->fd = socket(PF_UNIX, SOCK_DGRAM, 0);
if (iface->fd < 0) {
wpa_printf(MSG_ERROR, "socket(PF_UNIX): %s", strerror(errno));
wpa_priv_interface_deinit(iface);
return NULL;
}
os_memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
os_strlcpy(addr.sun_path, iface->sock_name, sizeof(addr.sun_path));
if (bind(iface->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
wpa_printf(MSG_DEBUG, "bind(PF_UNIX) failed: %s",
strerror(errno));
if (connect(iface->fd, (struct sockaddr *) &addr,
sizeof(addr)) < 0) {
wpa_printf(MSG_DEBUG, "Socket exists, but does not "
"allow connections - assuming it was "
"leftover from forced program termination");
if (unlink(iface->sock_name) < 0) {
wpa_printf(MSG_ERROR,
"Could not unlink existing ctrl_iface socket '%s': %s",
iface->sock_name, strerror(errno));
goto fail;
}
if (bind(iface->fd, (struct sockaddr *) &addr,
sizeof(addr)) < 0) {
wpa_printf(MSG_ERROR,
"wpa-priv-iface-init: bind(PF_UNIX): %s",
strerror(errno));
goto fail;
}
wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
"socket '%s'", iface->sock_name);
} else {
wpa_printf(MSG_INFO, "Socket exists and seems to be "
"in use - cannot override it");
wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
"not used anymore", iface->sock_name);
goto fail;
}
}
if (chmod(iface->sock_name, S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
wpa_printf(MSG_ERROR, "chmod: %s", strerror(errno));
goto fail;
}
eloop_register_read_sock(iface->fd, wpa_priv_receive, iface, NULL);
return iface;
fail:
wpa_priv_interface_deinit(iface);
return NULL;
}
S32 WpaCore_SetSsid(THandle hWpaCore, OS_802_11_SSID* ssid, TMacAddr bssid)
{
TWpaCore* pWpaCore = (TWpaCore*)hWpaCore;
S8 cmd[256];
S8 Resp[IPC_WPA_RESP_MAX_LEN];
PS8 pRespTemp;
U32 RespLen;
U32 NetworkID;
U32 SendCommand;
U8 Len;
#define WPACORE_SETSSID_FAIL \
os_error_printf(CU_MSG_ERROR, (PS8)"Failed to connect to %s\n", ssid->Ssid); \
return ECUERR_WPA_CORE_ERROR_FAILED_CONNECT_SSID;
/* First Add a new network block*/
os_sprintf(cmd, (PS8)"ADD_NETWORK");
if (IpcWpa_CommandWithResp(pWpaCore->hIpcWpa, cmd, TRUE, Resp, &RespLen))
{
WPACORE_SETSSID_FAIL;
}
NetworkID = os_strtoul(Resp, &pRespTemp, 0);
/* Set the parameters in the new new network block*/
/* Set the BSSID */
if(!((bssid[0] == 0xFF) &&
(bssid[1] == 0xFF) &&
(bssid[2] == 0xFF) &&
(bssid[3] == 0xFF) &&
(bssid[4] == 0xFF) &&
(bssid[5] == 0xFF)))
{
/* set th ebssid only if the bssid doesn't mean any bssid */
S8 temp[20];
os_sprintf(temp, (PS8)"%02x", bssid[0]);
os_sprintf(temp, (PS8)"%s:%02x", temp, bssid[1]);
os_sprintf(temp, (PS8)"%s:%02x", temp, bssid[2]);
os_sprintf(temp, (PS8)"%s:%02x", temp, bssid[3]);
os_sprintf(temp, (PS8)"%s:%02x", temp, bssid[4]);
os_sprintf(temp, (PS8)"%s:%02x", temp, bssid[5]);
os_sprintf(cmd, (PS8)"SET_NETWORK %d bssid %s", NetworkID, temp);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, FALSE))
{
WPACORE_SETSSID_FAIL;
}
}
/* Set the SSID */
os_sprintf(cmd, (PS8)"SET_NETWORK %d ssid \"%s\"", NetworkID, ssid->Ssid);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
/* set mode of the new network block */
os_sprintf(cmd, (PS8)"SET_NETWORK %d mode %d", NetworkID, pWpaCore->WpaSupplParams.mode);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
/* set proto of the new network block */
SendCommand = TRUE;
if (pWpaCore->WpaSupplParams.proto == WPA_PROTO_WPA)
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d proto WPA", NetworkID);
}
else if (pWpaCore->WpaSupplParams.proto == WPA_PROTO_RSN)
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d proto RSN", NetworkID);
}
else
{
SendCommand = FALSE;
}
if (SendCommand && IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
/* set key management of the new network block */
SendCommand = TRUE;
if (pWpaCore->WpaSupplParams.key_mgmt == WPA_KEY_MGMT_NONE)
{
if ((pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_LEAP) ||
(pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_PEAP) ||
(pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_FAST))
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d key_mgmt IEEE8021X", NetworkID);
}
else
os_sprintf(cmd, (PS8)"SET_NETWORK %d key_mgmt NONE", NetworkID);
}
else if (pWpaCore->WpaSupplParams.key_mgmt == WPA_KEY_MGMT_PSK)
os_sprintf(cmd, (PS8)"SET_NETWORK %d key_mgmt WPA-PSK", NetworkID);
else if (pWpaCore->WpaSupplParams.key_mgmt == WPA_KEY_MGMT_IEEE8021X)
#ifdef XCC_MODULE_INCLUDED
if((pWpaCore->WpaSupplParams.XCC == OS_XCC_CONFIGURATION_ENABLE_CCKM)||(pWpaCore->WpaSupplParams.XCC == OS_XCC_CONFIGURATION_ENABLE_ALL))
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d key_mgmt WPA-EAP CCKM", NetworkID);
}
else
#endif
os_sprintf(cmd, (PS8)"SET_NETWORK %d key_mgmt WPA-EAP", NetworkID);
else if (pWpaCore->WpaSupplParams.key_mgmt == WPA_KEY_MGMT_WPA_NONE)
os_sprintf(cmd, (PS8)"SET_NETWORK %d key_mgmt WPA-NONE", NetworkID);
else
{
SendCommand = FALSE;
}
if (SendCommand && IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
/* set authentication alog of the new network block */
SendCommand = TRUE;
if (pWpaCore->WpaSupplParams.auth_alg == WPA_AUTH_ALG_OPEN)
os_sprintf(cmd, (PS8)"SET_NETWORK %d auth_alg OPEN", NetworkID);
else if (pWpaCore->WpaSupplParams.auth_alg == WPA_AUTH_ALG_SHARED)
os_sprintf(cmd, (PS8)"SET_NETWORK %d auth_alg SHARED", NetworkID);
else if (pWpaCore->WpaSupplParams.auth_alg == WPA_AUTH_ALG_LEAP)
os_sprintf(cmd, (PS8)"SET_NETWORK %d auth_alg LEAP", NetworkID);
else
{
SendCommand = FALSE;
}
if (SendCommand && IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
/* set pairwise encryption of the new network block */
SendCommand = TRUE;
if (pWpaCore->WpaSupplParams.pair_wise == WPA_CIPHER_NONE)
os_sprintf(cmd, (PS8)"SET_NETWORK %d pairwise NONE", NetworkID);
else if (pWpaCore->WpaSupplParams.pair_wise == WPA_CIPHER_WEP40)
os_sprintf(cmd, (PS8)"SET_NETWORK %d pairwise NONE", NetworkID);
else if (pWpaCore->WpaSupplParams.pair_wise == WPA_CIPHER_TKIP)
os_sprintf(cmd, (PS8)"SET_NETWORK %d pairwise TKIP", NetworkID);
else if ((pWpaCore->WpaSupplParams.pair_wise == WPA_CIPHER_CCMP)&& (pWpaCore->WpaSupplParams.anyWpaMode == 0))
os_sprintf(cmd, (PS8)"SET_NETWORK %d pairwise CCMP", NetworkID);
else if ((pWpaCore->WpaSupplParams.pair_wise == WPA_CIPHER_CCMP)&& (pWpaCore->WpaSupplParams.anyWpaMode == 1))
os_sprintf(cmd, (PS8)"SET_NETWORK %d pairwise CCMP TKIP", NetworkID);
else
{
SendCommand = FALSE;
}
if (SendCommand && IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
/* set group encryption of the new network block */
SendCommand = TRUE;
if (pWpaCore->WpaSupplParams.group == WPA_CIPHER_WEP40)
os_sprintf(cmd, (PS8)"SET_NETWORK %d group WEP40", NetworkID);
else if (pWpaCore->WpaSupplParams.group == WPA_CIPHER_TKIP)
os_sprintf(cmd, (PS8)"SET_NETWORK %d group TKIP", NetworkID);
else if ((pWpaCore->WpaSupplParams.group == WPA_CIPHER_CCMP)&& (pWpaCore->WpaSupplParams.anyWpaMode == 0))
os_sprintf(cmd, (PS8)"SET_NETWORK %d group CCMP", NetworkID);
else if ((pWpaCore->WpaSupplParams.group == WPA_CIPHER_CCMP)&& (pWpaCore->WpaSupplParams.anyWpaMode == 1))
os_sprintf(cmd, (PS8)"SET_NETWORK %d group CCMP TKIP", NetworkID);
else
{
SendCommand = FALSE;
}
if (SendCommand && IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
/* set eap of the new network block */
if (pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_NONE)
SendCommand = FALSE;
else
{
SendCommand = TRUE;
if (pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_MD5_CHALLENGE)
os_sprintf(cmd, (PS8)"SET_NETWORK %d eap MD5", NetworkID);
else if (pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_GENERIC_TOKEN_CARD)
os_sprintf(cmd, (PS8)"SET_NETWORK %d eap GTC", NetworkID);
else if (pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_TLS)
os_sprintf(cmd, (PS8)"SET_NETWORK %d eap TLS", NetworkID);
else if (pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_TTLS)
os_sprintf(cmd, (PS8)"SET_NETWORK %d eap TTLS", NetworkID);
else if (pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_PEAP)
os_sprintf(cmd, (PS8)"SET_NETWORK %d eap PEAP", NetworkID);
else if (pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_MS_CHAP_V2)
os_sprintf(cmd, (PS8)"SET_NETWORK %d eap MSCHAPV2", NetworkID);
#ifdef XCC_MODULE_INCLUDED
else if (pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_LEAP)
os_sprintf(cmd, (PS8)"SET_NETWORK %d eap LEAP", NetworkID);
else if (pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_FAST)
os_sprintf(cmd, (PS8)"SET_NETWORK %d eap FAST", NetworkID);
#endif
else
SendCommand = FALSE;
}
if (SendCommand && IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
if (pWpaCore->WpaSupplParams.Identity[0])
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d identity \"%s\"", NetworkID,pWpaCore->WpaSupplParams.Identity);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
if (pWpaCore->WpaSupplParams.client_cert[0])
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d client_cert \"%s\"", NetworkID,pWpaCore->WpaSupplParams.client_cert);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
if (pWpaCore->WpaSupplParams.client_cert[0])
{
Len = os_strlen ((PS8)pWpaCore->WpaSupplParams.client_cert);
os_memcpy(pWpaCore->WpaSupplParams.private_key,pWpaCore->WpaSupplParams.client_cert,Len);
os_memcpy(&pWpaCore->WpaSupplParams.private_key[Len-3],"pem",3);
os_sprintf(cmd, (PS8)"SET_NETWORK %d private_key \"%s\"", NetworkID,pWpaCore->WpaSupplParams.private_key);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
if (pWpaCore->WpaSupplParams.private_key_passwd[0] )
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d private_key_passwd \"%s\"", NetworkID,pWpaCore->WpaSupplParams.private_key_passwd);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
if (pWpaCore->WpaSupplParams.password[0] )
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d password \"%s\"", NetworkID,pWpaCore->WpaSupplParams.password);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
if (pWpaCore->WpaSupplParams.eap == OS_EAP_TYPE_FAST)
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d phase1 \"fast_provisioning=3\"", NetworkID);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
os_sprintf(cmd, (PS8)"SET_NETWORK %d pac_file \"/etc/wpa_supplicant.eap-fast-pac\"", NetworkID);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
os_sprintf(cmd, (PS8)"SET_NETWORK %d anonymous_identity \"anonymous\"", NetworkID);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
if (pWpaCore->WpaSupplParams.pair_wise == WPA_CIPHER_WEP40)
{
S32 idx, idx2;
for (idx=0; idx<4; idx++)
{
S8 TempBuf[3];
os_sprintf(cmd, (PS8)"SET_NETWORK %d wep_key%d ", NetworkID, idx);
for (idx2=0; idx2 < pWpaCore->WpaSupplParams.wep_key_length; idx2++)
{
os_sprintf(TempBuf, (PS8)"%02x", pWpaCore->WpaSupplParams.wep_key[idx][idx2]);
os_strcat (cmd, TempBuf);
}
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
os_sprintf(cmd, (PS8)"SET_NETWORK %d wep_tx_keyidx %d", NetworkID, pWpaCore->WpaSupplParams.default_wep_key-1);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
if (pWpaCore->WpaSupplParams.key_mgmt == WPA_KEY_MGMT_PSK)
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d psk \"%s\"", NetworkID, pWpaCore->WpaSupplParams.pass_phrase);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
#ifdef CONFIG_WPS
if (pWpaCore->WpaSupplParams.WscMode)
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d wsc_mode %d", NetworkID, pWpaCore->WpaSupplParams.WscMode);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
if (pWpaCore->WpaSupplParams.pWscPin)
{
os_sprintf(cmd, (PS8)"SET_NETWORK %d wsc_pin \"%s\"", NetworkID, pWpaCore->WpaSupplParams.pWscPin);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
}
#endif
/* Finaly Connect to the new network block */
os_sprintf(cmd, (PS8)"SELECT_NETWORK %d", NetworkID);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 0))
{
WPACORE_SETSSID_FAIL;
}
pWpaCore->CurrentNetwork = NetworkID;
IpcWpa_Command(pWpaCore->hIpcWpa, (PS8)"SAVE_CONFIG", 1);
/*
init the connection params thus the next time we connect we will by default
connect to an open
*/
WpaCore_InitWpaParams(pWpaCore);
return OK;
}
static int hapd_wps_cred_cb(struct hostapd_data *hapd, void *ctx)
{
const struct wps_credential *cred = ctx;
FILE *oconf, *nconf;
size_t len, i;
char *tmp_fname;
char buf[1024];
int multi_bss;
int wpa;
if (hapd->wps == NULL)
return 0;
wpa_hexdump_key(MSG_DEBUG, "WPS: Received Credential attribute",
cred->cred_attr, cred->cred_attr_len);
wpa_printf(MSG_DEBUG, "WPS: Received new AP Settings");
wpa_hexdump_ascii(MSG_DEBUG, "WPS: SSID", cred->ssid, cred->ssid_len);
wpa_printf(MSG_DEBUG, "WPS: Authentication Type 0x%x",
cred->auth_type);
wpa_printf(MSG_DEBUG, "WPS: Encryption Type 0x%x", cred->encr_type);
wpa_printf(MSG_DEBUG, "WPS: Network Key Index %d", cred->key_idx);
wpa_hexdump_key(MSG_DEBUG, "WPS: Network Key",
cred->key, cred->key_len);
wpa_printf(MSG_DEBUG, "WPS: MAC Address " MACSTR,
MAC2STR(cred->mac_addr));
if ((hapd->conf->wps_cred_processing == 1 ||
hapd->conf->wps_cred_processing == 2) && cred->cred_attr) {
hapd_new_ap_event(hapd, cred->cred_attr, cred->cred_attr_len);
} else if (hapd->conf->wps_cred_processing == 1 ||
hapd->conf->wps_cred_processing == 2) {
struct wpabuf *attr;
attr = wpabuf_alloc(200);
if (attr && wps_build_credential_wrap(attr, cred) == 0)
hapd_new_ap_event(hapd, wpabuf_head_u8(attr),
wpabuf_len(attr));
wpabuf_free(attr);
} else
wpa_msg(hapd->msg_ctx, MSG_INFO, WPS_EVENT_NEW_AP_SETTINGS);
if (hapd->conf->wps_cred_processing == 1)
return 0;
os_memcpy(hapd->wps->ssid, cred->ssid, cred->ssid_len);
hapd->wps->ssid_len = cred->ssid_len;
hapd->wps->encr_types = cred->encr_type;
hapd->wps->auth_types = cred->auth_type;
if (cred->key_len == 0) {
os_free(hapd->wps->network_key);
hapd->wps->network_key = NULL;
hapd->wps->network_key_len = 0;
} else {
if (hapd->wps->network_key == NULL ||
hapd->wps->network_key_len < cred->key_len) {
hapd->wps->network_key_len = 0;
os_free(hapd->wps->network_key);
hapd->wps->network_key = os_malloc(cred->key_len);
if (hapd->wps->network_key == NULL)
return -1;
}
hapd->wps->network_key_len = cred->key_len;
os_memcpy(hapd->wps->network_key, cred->key, cred->key_len);
}
hapd->wps->wps_state = WPS_STATE_CONFIGURED;
if (hapd->iface->config_fname == NULL)
return 0;
len = os_strlen(hapd->iface->config_fname) + 5;
tmp_fname = os_malloc(len);
if (tmp_fname == NULL)
return -1;
os_snprintf(tmp_fname, len, "%s-new", hapd->iface->config_fname);
oconf = fopen(hapd->iface->config_fname, "r");
if (oconf == NULL) {
wpa_printf(MSG_WARNING, "WPS: Could not open current "
"configuration file");
os_free(tmp_fname);
return -1;
}
nconf = fopen(tmp_fname, "w");
if (nconf == NULL) {
wpa_printf(MSG_WARNING, "WPS: Could not write updated "
"configuration file");
os_free(tmp_fname);
fclose(oconf);
return -1;
}
fprintf(nconf, "# WPS configuration - START\n");
fprintf(nconf, "wps_state=2\n");
if (is_hex(cred->ssid, cred->ssid_len)) {
fprintf(nconf, "ssid2=");
for (i = 0; i < cred->ssid_len; i++)
fprintf(nconf, "%02x", cred->ssid[i]);
fprintf(nconf, "\n");
} else {
fprintf(nconf, "ssid=");
for (i = 0; i < cred->ssid_len; i++)
fputc(cred->ssid[i], nconf);
fprintf(nconf, "\n");
}
if ((cred->auth_type & (WPS_AUTH_WPA2 | WPS_AUTH_WPA2PSK)) &&
(cred->auth_type & (WPS_AUTH_WPA | WPS_AUTH_WPAPSK)))
wpa = 3;
else if (cred->auth_type & (WPS_AUTH_WPA2 | WPS_AUTH_WPA2PSK))
wpa = 2;
else if (cred->auth_type & (WPS_AUTH_WPA | WPS_AUTH_WPAPSK))
wpa = 1;
else
wpa = 0;
if (wpa) {
char *prefix;
fprintf(nconf, "wpa=%d\n", wpa);
fprintf(nconf, "wpa_key_mgmt=");
prefix = "";
if (cred->auth_type & (WPS_AUTH_WPA2 | WPS_AUTH_WPA)) {
fprintf(nconf, "WPA-EAP");
prefix = " ";
}
if (cred->auth_type & (WPS_AUTH_WPA2PSK | WPS_AUTH_WPAPSK))
fprintf(nconf, "%sWPA-PSK", prefix);
fprintf(nconf, "\n");
fprintf(nconf, "wpa_pairwise=");
prefix = "";
if (cred->encr_type & WPS_ENCR_AES) {
fprintf(nconf, "CCMP");
prefix = " ";
}
if (cred->encr_type & WPS_ENCR_TKIP) {
fprintf(nconf, "%sTKIP", prefix);
}
fprintf(nconf, "\n");
if (cred->key_len >= 8 && cred->key_len < 64) {
fprintf(nconf, "wpa_passphrase=");
for (i = 0; i < cred->key_len; i++)
fputc(cred->key[i], nconf);
fprintf(nconf, "\n");
} else if (cred->key_len == 64) {
fprintf(nconf, "wpa_psk=");
for (i = 0; i < cred->key_len; i++)
fputc(cred->key[i], nconf);
fprintf(nconf, "\n");
} else {
wpa_printf(MSG_WARNING, "WPS: Invalid key length %lu "
"for WPA/WPA2",
(unsigned long) cred->key_len);
}
fprintf(nconf, "auth_algs=1\n");
} else {
if ((cred->auth_type & WPS_AUTH_OPEN) &&
(cred->auth_type & WPS_AUTH_SHARED))
fprintf(nconf, "auth_algs=3\n");
else if (cred->auth_type & WPS_AUTH_SHARED)
fprintf(nconf, "auth_algs=2\n");
else
fprintf(nconf, "auth_algs=1\n");
if (cred->encr_type & WPS_ENCR_WEP && cred->key_idx <= 4) {
int key_idx = cred->key_idx;
if (key_idx)
key_idx--;
fprintf(nconf, "wep_default_key=%d\n", key_idx);
fprintf(nconf, "wep_key%d=", key_idx);
if (cred->key_len == 10 || cred->key_len == 26) {
/* WEP key as a hex string */
for (i = 0; i < cred->key_len; i++)
fputc(cred->key[i], nconf);
} else {
/* Raw WEP key; convert to hex */
for (i = 0; i < cred->key_len; i++)
fprintf(nconf, "%02x", cred->key[i]);
}
fprintf(nconf, "\n");
}
}
fprintf(nconf, "# WPS configuration - END\n");
multi_bss = 0;
while (fgets(buf, sizeof(buf), oconf)) {
if (os_strncmp(buf, "bss=", 4) == 0)
multi_bss = 1;
if (!multi_bss &&
(str_starts(buf, "ssid=") ||
str_starts(buf, "ssid2=") ||
str_starts(buf, "auth_algs=") ||
str_starts(buf, "wep_default_key=") ||
str_starts(buf, "wep_key") ||
str_starts(buf, "wps_state=") ||
str_starts(buf, "wpa=") ||
str_starts(buf, "wpa_psk=") ||
str_starts(buf, "wpa_pairwise=") ||
str_starts(buf, "rsn_pairwise=") ||
str_starts(buf, "wpa_key_mgmt=") ||
str_starts(buf, "wpa_passphrase="))) {
fprintf(nconf, "#WPS# %s", buf);
} else
fprintf(nconf, "%s", buf);
}
fclose(nconf);
fclose(oconf);
if (rename(tmp_fname, hapd->iface->config_fname) < 0) {
wpa_printf(MSG_WARNING, "WPS: Failed to rename the updated "
"configuration file: %s", strerror(errno));
os_free(tmp_fname);
return -1;
}
os_free(tmp_fname);
/* Schedule configuration reload after short period of time to allow
* EAP-WSC to be finished.
*/
eloop_register_timeout(0, 100000, wps_reload_config, hapd->iface,
NULL);
wpa_printf(MSG_DEBUG, "WPS: AP configuration updated");
return 0;
}
/* subscr_addr_add_url -- add address(es) for one url to subscription */
static void subscr_addr_add_url(struct subscription *s, const char *url,
size_t url_len)
{
int alloc_len;
char *scratch_mem = NULL;
char *mem;
char *host;
char *delim;
char *path;
int port = 80; /* port to send to (default is port 80) */
struct addrinfo hints;
struct addrinfo *result = NULL;
struct addrinfo *rp;
int rerr;
size_t host_len, path_len;
/* url MUST begin with http: */
if (url_len < 7 || os_strncasecmp(url, "http://", 7))
goto fail;
url += 7;
url_len -= 7;
/* Make a copy of the string to allow modification during parsing */
scratch_mem = dup_binstr(url, url_len);
if (scratch_mem == NULL)
goto fail;
wpa_printf(MSG_DEBUG, "WPS UPnP: Adding URL '%s'", scratch_mem);
host = scratch_mem;
path = os_strchr(host, '/');
if (path)
*path++ = '\0'; /* null terminate host */
/* Process and remove optional port component */
delim = os_strchr(host, ':');
if (delim) {
*delim = '\0'; /* null terminate host name for now */
if (isdigit(delim[1]))
port = atol(delim + 1);
}
/*
* getaddrinfo does the right thing with dotted decimal notations, or
* will resolve domain names. Resolving domain names will unfortunately
* hang the entire program until it is resolved or it times out
* internal to getaddrinfo; fortunately we think that the use of actual
* domain names (vs. dotted decimal notations) should be uncommon.
*/
os_memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_INET; /* IPv4 */
hints.ai_socktype = SOCK_STREAM;
#if NO_DOMAIN_NAME_RESOLUTION
/* Suppress domain name resolutions that would halt
* the program for periods of time
*/
hints.ai_flags = AI_NUMERICHOST;
#else
/* Allow domain name resolution. */
hints.ai_flags = 0;
#endif
hints.ai_protocol = 0; /* Any protocol? */
rerr = getaddrinfo(host, NULL /* fill in port ourselves */,
&hints, &result);
if (rerr) {
wpa_printf(MSG_INFO, "WPS UPnP: Resolve error %d (%s) on: %s",
rerr, gai_strerror(rerr), host);
goto fail;
}
if (delim)
*delim = ':'; /* Restore port */
host_len = os_strlen(host);
path_len = path ? os_strlen(path) : 0;
alloc_len = host_len + 1 + 1 + path_len + 1;
for (rp = result; rp; rp = rp->ai_next) {
struct subscr_addr *a;
/* Limit no. of address to avoid denial of service attack */
if (dl_list_len(&s->addr_list) >= MAX_ADDR_PER_SUBSCRIPTION) {
wpa_printf(MSG_INFO, "WPS UPnP: subscr_addr_add_url: "
"Ignoring excessive addresses");
break;
}
a = os_zalloc(sizeof(*a) + alloc_len);
if (a == NULL)
break;
mem = (char *) (a + 1);
a->domain_and_port = mem;
os_memcpy(mem, host, host_len);
mem += host_len + 1;
a->path = mem;
if (path == NULL || path[0] != '/')
*mem++ = '/';
if (path)
os_memcpy(mem, path, path_len);
os_memcpy(&a->saddr, rp->ai_addr, sizeof(a->saddr));
a->saddr.sin_port = htons(port);
dl_list_add(&s->addr_list, &a->list);
}
fail:
if (result)
freeaddrinfo(result);
os_free(scratch_mem);
}
/**
* @brief MQTT initialization mqtt client function
* @param client: MQTT_Client reference
* @param clientid: MQTT client id
* @param client_user:MQTT client user
* @param client_pass:MQTT client password
* @param client_pass:MQTT keep alive timer, in second
* @retval None
*/
BOOL ICACHE_FLASH_ATTR
MQTT_InitClient(MQTT_Client * mqttClient, uint8_t * client_id, uint8_t * client_user, uint8_t * client_pass,
uint32_t keepAliveTime, uint8_t cleanSession) {
uint32_t temp;
MQTT_INFO("MQTT:InitClient\r\n");
os_memset(&mqttClient->connect_info, 0, sizeof(mqtt_connect_info_t));
if (!client_id) {
/* Should be allowed by broker, but clean session flag must be set. */
#ifdef PROTOCOL_NAMEv311
if (cleanSession) {
mqttClient->connect_info.client_id = zero_len_id;
} else {
MQTT_INFO("cleanSession must be set to use 0 length client_id\r\n");
return false;
}
/* Not supported. Return. */
#else
MQTT_INFO("Client ID required for MQTT < 3.1.1!\r\n");
return false;
#endif
}
/* If connect_info's client_id is still NULL and we get here, we can *
* assume the passed client_id is non-NULL. */
if (!(mqttClient->connect_info.client_id)) {
temp = os_strlen(client_id);
mqttClient->connect_info.client_id = (uint8_t *) os_zalloc(temp + 1);
os_strcpy(mqttClient->connect_info.client_id, client_id);
mqttClient->connect_info.client_id[temp] = 0;
}
if (client_user) {
temp = os_strlen(client_user);
mqttClient->connect_info.username = (uint8_t *) os_zalloc(temp + 1);
os_strcpy(mqttClient->connect_info.username, client_user);
mqttClient->connect_info.username[temp] = 0;
}
if (client_pass) {
temp = os_strlen(client_pass);
mqttClient->connect_info.password = (uint8_t *) os_zalloc(temp + 1);
os_strcpy(mqttClient->connect_info.password, client_pass);
mqttClient->connect_info.password[temp] = 0;
}
mqttClient->connect_info.keepalive = keepAliveTime;
mqttClient->connect_info.clean_session = cleanSession;
mqttClient->mqtt_state.in_buffer = (uint8_t *) os_zalloc(MQTT_BUF_SIZE);
mqttClient->mqtt_state.in_buffer_length = MQTT_BUF_SIZE;
mqttClient->mqtt_state.out_buffer = (uint8_t *) os_zalloc(MQTT_BUF_SIZE);
mqttClient->mqtt_state.out_buffer_length = MQTT_BUF_SIZE;
mqttClient->mqtt_state.connect_info = &mqttClient->connect_info;
mqtt_msg_init(&mqttClient->mqtt_state.mqtt_connection, mqttClient->mqtt_state.out_buffer,
mqttClient->mqtt_state.out_buffer_length);
QUEUE_Init(&mqttClient->msgQueue, QUEUE_BUFFER_SIZE);
system_os_task(MQTT_Task, MQTT_TASK_PRIO, mqtt_procTaskQueue, MQTT_TASK_QUEUE_SIZE);
system_os_post(MQTT_TASK_PRIO, 0, (os_param_t) mqttClient);
return true;
}
/**
* upnp_wps_device_send_event - Queue event messages for subscribers
* @sm: WPS UPnP state machine from upnp_wps_device_init()
*
* This function queues the last WLANEvent to be sent for all currently
* subscribed UPnP control points. sm->wlanevent must have been set with the
* encoded data before calling this function.
*/
static void upnp_wps_device_send_event(struct upnp_wps_device_sm *sm)
{
/* Enqueue event message for all subscribers */
struct wpabuf *buf; /* holds event message */
int buf_size = 0;
struct subscription *s, *tmp;
/* Actually, utf-8 is the default, but it doesn't hurt to specify it */
const char *format_head =
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
"<e:propertyset xmlns:e=\"urn:schemas-upnp-org:event-1-0\">\n";
const char *format_tail = "</e:propertyset>\n";
struct os_reltime now;
if (dl_list_empty(&sm->subscriptions)) {
/* optimize */
return;
}
if (os_get_reltime(&now) == 0) {
if (now.sec != sm->last_event_sec) {
sm->last_event_sec = now.sec;
sm->num_events_in_sec = 1;
} else {
sm->num_events_in_sec++;
/*
* In theory, this should apply to all WLANEvent
* notifications, but EAP messages are of much higher
* priority and Probe Request notifications should not
* be allowed to drop EAP messages, so only throttle
* Probe Request notifications.
*/
if (sm->num_events_in_sec > MAX_EVENTS_PER_SEC &&
sm->wlanevent_type ==
UPNP_WPS_WLANEVENT_TYPE_PROBE) {
wpa_printf(MSG_DEBUG, "WPS UPnP: Throttle "
"event notifications (%u seen "
"during one second)",
sm->num_events_in_sec);
return;
}
}
}
/* Determine buffer size needed first */
buf_size += os_strlen(format_head);
buf_size += 50 + 2 * os_strlen("WLANEvent");
if (sm->wlanevent)
buf_size += os_strlen(sm->wlanevent);
buf_size += os_strlen(format_tail);
buf = wpabuf_alloc(buf_size);
if (buf == NULL)
return;
wpabuf_put_str(buf, format_head);
wpabuf_put_property(buf, "WLANEvent", sm->wlanevent);
wpabuf_put_str(buf, format_tail);
wpa_printf(MSG_MSGDUMP, "WPS UPnP: WLANEvent message:\n%s",
(char *) wpabuf_head(buf));
dl_list_for_each_safe(s, tmp, &sm->subscriptions, struct subscription,
list) {
event_add(s, buf,
sm->wlanevent_type == UPNP_WPS_WLANEVENT_TYPE_PROBE);
}
wpabuf_free(buf);
}
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;
struct wpa_supplicant *wpa_s;
struct hostapd_data *hapd;
int handled = 0;
int cmd_len = 0;
union wpa_event_data event;
static int user_force_band = 0;
int ret = -1;
if (drv == NULL) {
wpa_printf(MSG_ERROR, "%s: drv is NULL. Exiting", __func__);
return -1;
}
if (drv->ctx == NULL) {
wpa_printf(MSG_ERROR, "%s: drv->ctx is NULL. Exiting", __func__);
return -1;
}
if (os_strcmp(bss->ifname, "ap0") == 0) {
hapd = (struct hostapd_data *)(drv->ctx);
}
else {
wpa_s = (struct wpa_supplicant *)(drv->ctx);
if (wpa_s->conf == NULL) {
wpa_printf(MSG_ERROR, "%s: wpa_s->conf is NULL. Exiting", __func__);
return -1;
}
}
wpa_printf(MSG_DEBUG, "iface %s recv cmd %s", bss->ifname, cmd);
handled = 1;
if (os_strncasecmp(cmd, "POWERMODE ", 10) == 0) {
int state;
state = atoi(cmd + 10);
wpa_printf(MSG_DEBUG, "POWERMODE=%d", state);
} else if (os_strncmp(cmd, "MACADDR", os_strlen("MACADDR")) == 0) {
u8 macaddr[ETH_ALEN] = {};
os_memcpy(&macaddr, wpa_s->own_addr, ETH_ALEN);
ret = snprintf(buf, buf_len, "Macaddr = " MACSTR "\n", MAC2STR(macaddr));
wpa_printf(MSG_DEBUG, "%s", buf);
} else if(os_strncasecmp(cmd, "COUNTRY", os_strlen("COUNTRY"))==0) {
if (os_strlen(cmd) != os_strlen("COUNTRY") + 3) {
wpa_printf(MSG_DEBUG, "Ignore COUNTRY cmd %s", cmd);
ret = 0;
} else {
wpa_printf(MSG_INFO, "set country: %s", cmd+8);
// ret = wpa_drv_set_country(wpa_s, cmd+8);
ret = wpa_driver_mediatek_set_country(priv, cmd+8);
if (ret == 0) {
wpa_printf(MSG_DEBUG, "Update channel list after country code changed");
wpa_driver_notify_country_change(wpa_s, cmd);
}
}
} else if (os_strcasecmp(cmd, "start") == 0) {
if (ret = linux_set_iface_flags(drv->global->ioctl_sock,
drv->first_bss->ifname, 1)) {
wpa_printf(MSG_INFO, "nl80211: Could not set interface UP, ret=%d \n", ret);
} else {
wpa_msg(drv->ctx, MSG_INFO, "CTRL-EVENT-DRIVER-STATE STARTED");
}
} else if (os_strcasecmp(cmd, "stop") == 0) {
if (drv->associated) {
ret = wpa_drv_deauthenticate(wpa_s, drv->bssid, WLAN_REASON_DEAUTH_LEAVING);
if (ret != 0)
wpa_printf(MSG_DEBUG, "DRIVER-STOP error, ret=%d", ret);
} else {
wpa_printf(MSG_INFO, "nl80211: not associated, no need to deauthenticate \n");
}
if (ret = linux_set_iface_flags(drv->global->ioctl_sock,
drv->first_bss->ifname, 0)) {
wpa_printf(MSG_INFO, "nl80211: Could not set interface Down, ret=%d \n", ret);
} else {
wpa_msg(drv->ctx, MSG_INFO, "CTRL-EVENT-DRIVER-STATE STOPPED");
}
} else if (os_strncasecmp(cmd, "getpower", 8) == 0) {
u32 mode;
// ret = wpa_driver_wext_driver_get_power(drv, &mode);
if (ret == 0) {
ret = snprintf(buf, buf_len, "powermode = %u\n", mode);
wpa_printf(MSG_DEBUG, "%s", buf);
if (ret < (int)buf_len)
return ret;
}
} else if (os_strncasecmp(cmd, "get-rts-threshold", 17) == 0) {
u32 thd;
// ret = wpa_driver_wext_driver_get_rts(drv, &thd);
if (ret == 0) {
ret = snprintf(buf, buf_len, "rts-threshold = %u\n", thd);
wpa_printf(MSG_DEBUG, "%s", buf);
if (ret < (int)buf_len)
return ret;
}
} else if (os_strncasecmp(cmd, "set-rts-threshold", 17) == 0) {
u32 thd = 0;
char *cp = cmd + 17;
char *endp;
if (*cp != '\0') {
thd = (u32)strtol(cp, &endp, 0);
// if (endp != cp)
// ret = wpa_driver_wext_driver_set_rts(drv, thd);
}
} else if (os_strcasecmp(cmd, "btcoexscan-start") == 0) {
ret = 0; /* mt5921 linux driver not implement yet */
} else if (os_strcasecmp(cmd, "btcoexscan-stop") == 0) {
ret = 0; /* mt5921 linux driver not implement yet */
} else if (os_strncasecmp(cmd, "btcoexmode", 10) == 0) {
ret = 0; /* mt5921 linux driver not implement yet */
} else {
handled = 0;
wpa_printf(MSG_INFO, "Unsupported command");
}
return ret;
}
/* subscription_first_event -- send format/queue event that is automatically
* sent on a new subscription.
*/
static int subscription_first_event(struct subscription *s)
{
/*
* Actually, utf-8 is the default, but it doesn't hurt to specify it.
*
* APStatus is apparently a bit set,
* 0x1 = configuration change (but is always set?)
* 0x10 = ap is locked
*
* Per UPnP spec, we send out the last value of each variable, even
* for WLANEvent, whatever it was.
*/
char *wlan_event;
struct wpabuf *buf;
int ap_status = 1; /* TODO: add 0x10 if access point is locked */
const char *head =
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
"<e:propertyset xmlns:e=\"urn:schemas-upnp-org:event-1-0\">\n";
const char *tail = "</e:propertyset>\n";
char txt[10];
int ret;
if (s->sm->wlanevent == NULL) {
/*
* There has been no events before the subscription. However,
* UPnP device architecture specification requires all the
* evented variables to be included, so generate a dummy event
* for this particular case using a WSC_ACK and all-zeros
* nonces. The ER (UPnP control point) will ignore this, but at
* least it will learn that WLANEvent variable will be used in
* event notifications in the future.
*/
struct wpabuf *msg;
wpa_printf(MSG_DEBUG, "WPS UPnP: Use a fake WSC_ACK as the "
"initial WLANEvent");
msg = build_fake_wsc_ack();
if (msg) {
s->sm->wlanevent = (char *)
base64_encode(wpabuf_head(msg),
wpabuf_len(msg), NULL);
wpabuf_free(msg);
}
}
wlan_event = s->sm->wlanevent;
if (wlan_event == NULL || *wlan_event == '\0') {
wpa_printf(MSG_DEBUG, "WPS UPnP: WLANEvent not known for "
"initial event message");
wlan_event = "";
}
buf = wpabuf_alloc(500 + os_strlen(wlan_event));
if (buf == NULL)
return -1;
wpabuf_put_str(buf, head);
wpabuf_put_property(buf, "STAStatus", "1");
os_snprintf(txt, sizeof(txt), "%d", ap_status);
wpabuf_put_property(buf, "APStatus", txt);
if (*wlan_event)
wpabuf_put_property(buf, "WLANEvent", wlan_event);
wpabuf_put_str(buf, tail);
ret = event_add(s, buf, 0);
if (ret) {
wpabuf_free(buf);
return ret;
}
wpabuf_free(buf);
return 0;
}
static int wps_attr_parse_tests(void)
{
struct wps_parse_attr attr;
unsigned int i;
int ret = 0;
wpa_printf(MSG_INFO, "WPS attribute parsing tests");
for (i = 0; i < ARRAY_SIZE(wps_attr_parse_test_cases); i++) {
struct wpabuf *buf;
size_t len;
const struct wps_attr_parse_test *test =
&wps_attr_parse_test_cases[i];
len = os_strlen(test->data) / 2;
buf = wpabuf_alloc(len);
if (buf == NULL)
return -1;
if (hexstr2bin(test->data, wpabuf_put(buf, len), len) < 0) {
wpabuf_free(buf);
return -1;
}
if (wps_parse_msg(buf, &attr) != test->result) {
wpa_printf(MSG_ERROR, "WPS attribute parsing test %u failed: %s",
i, test->data);
ret = -1;
}
switch (test->extra) {
case 1:
if (!attr.network_key || !attr.ap_setup_locked)
ret = -1;
break;
case 2:
if (attr.num_cred != MAX_CRED_COUNT)
ret = -1;
break;
case 3:
if (!attr.network_key_idx)
ret = -1;
break;
case 4:
if (attr.num_req_dev_type != MAX_REQ_DEV_TYPE_COUNT)
ret = -1;
break;
case 5:
if (attr.num_vendor_ext != MAX_WPS_PARSE_VENDOR_EXT)
ret = -1;
break;
case 6:
if (!attr.version2 ||
!attr.authorized_macs ||
!attr.network_key_shareable ||
!attr.request_to_enroll ||
!attr.settings_delay_time)
ret = -1;
break;
}
wpabuf_free(buf);
}
return ret;
}
int ICACHE_FLASH_ATTR http_ws_handle_connect(http_connection *c) {
NODE_DBG("http_ws_handle_connect c =%p",c);
if(c->state == HTTPD_STATE_ON_URL){
http_set_save_header(c,HTTP_ORIGIN);
http_set_save_header(c,HTTP_CONNECTION);
http_set_save_header(c,HTTP_UPGRADE);
http_set_save_header(c,HTTP_SEC_WEBSOCKET_KEY);
http_set_save_header(c,HTTP_SEC_WEBSOCKET_PROTOCOL);
http_set_save_header(c,HTTP_SEC_WEBSOCKET_VERSION);
return HTTP_WS_CGI_MORE;
}
//wait handshake request complete
if(c->state != HTTPD_STATE_BODY_END)
return HTTP_WS_CGI_MORE;
header * upgrade_header = http_get_header(c,HTTP_UPGRADE);
header * connection_header = http_get_header(c,HTTP_CONNECTION);
header * origin_header = http_get_header(c,HTTP_ORIGIN);
header * key_header = http_get_header(c,HTTP_SEC_WEBSOCKET_KEY);
if(upgrade_header==NULL) goto badrequest;
if(connection_header==NULL) goto badrequest;
if(origin_header==NULL) goto badrequest;
if(key_header==NULL) goto badrequest;
NODE_DBG("headers ok");
if(os_strcasecmp(upgrade_header->value,"websocket")!=0) goto badrequest;
// Following (https://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17)
//calculate sha1 of concatenetion key+uuid
uint8_t digest[20]; //sha1 is always 20 byte long
SHA1_CTX ctx;
SHA1_Init(&ctx);
SHA1_Update(&ctx,key_header->value,os_strlen(key_header->value));
SHA1_Update(&ctx,ws_uuid,os_strlen(ws_uuid));
SHA1_Final(digest,&ctx);
char base64Digest[31]; //
Base64encode(base64Digest,(const char*)digest,20);
//accept the handshake
http_SET_HEADER(c,HTTP_UPGRADE,"websocket");
http_SET_HEADER(c,HTTP_CONNECTION,"Upgrade");
http_SET_HEADER(c,HTTP_WEBSOCKET_ACCEPT,base64Digest);
http_websocket_HANDSHAKE(c);
c->handshake_ok=1;
if(client_connected_callback!=NULL)
client_connected_callback(c);
return HTTP_WS_CGI_MORE;
badrequest:
http_response_BAD_REQUEST(c);
return HTTP_WS_CGI_DONE;
}
