static UINT8 SetMode_idle(void)
{
UINT8 networkType;
WF_CPGetNetworkType(iwconfigCb.cpId, &networkType);
if (FALSE == iwconfigCb.isIdle )
{
if (WF_CMDisconnect() != WF_SUCCESS)
{
putsUART("Disconnect failed. Disconnect is allowed only when module is in connected state\r\n");
}
WF_PsPollDisable();
#ifdef STACK_USE_CERTIFICATE_DEBUG
DelayMs(100);
#endif
}
return networkType;
}
/*******************************************************************************
Function:
BOOL iwconfigSetMode(void)
Summary:
Set the mode to idle, managed or adhoc.
Description:
Idle mode - Force MRF24W module to disconnect from any currently connected network
Managed mode - MRF24W module will connect to SSID in infrastructure mode. Ensure all network
parameters are correct before this command is invoked.
Adhoc mode - MRF24W module will connect to SSID in adhoc mode. Ensure all network
parameters are correct before this command is invoked.
Parameters:
Mode - idle / managed /adhoc
Returns:
TRUE or FALSE
Remarks:
None.
*****************************************************************************/
static BOOL iwconfigSetMode(void)
{
UINT8 networkType;
WF_CPGetNetworkType(iwconfigCb.cpId, &networkType);
if ( (3u <= ARGC) && (strcmppgm2ram((char*)ARGV[2], "idle") == 0) )
{
if ( iwconfigCb.isIdle )
{
WFConsolePrintRomStr("Already in the idle mode", TRUE);
}
else
{
if (WF_CMDisconnect() != WF_SUCCESS)
{
#if defined(STACK_USE_UART)
putsUART("Disconnect failed. Disconnect is allowed only when module is in connected state\r\n");
#endif
}
WF_PsPollDisable();
}
}
else if ( (3u <= ARGC) && (strcmppgm2ram((char*)ARGV[2], "managed") == 0) )
{
if ( iwconfigCb.isIdle )
{
WF_CPSetNetworkType(iwconfigCb.cpId, WF_INFRASTRUCTURE);
WF_CMConnect(iwconfigCb.cpId);
}
else
{
WF_CPGetNetworkType(iwconfigCb.cpId, &networkType);
if (networkType == WF_INFRASTRUCTURE)
{
WFConsolePrintRomStr("Already in the managed mode", TRUE);
}
else
{
if (WF_CMDisconnect() != WF_SUCCESS)
{
#if defined(STACK_USE_UART)
putsUART("Disconnect failed. Disconnect is allowed only when module is in connected state\r\n");
#endif
}
WF_CPSetNetworkType(iwconfigCb.cpId, WF_INFRASTRUCTURE);
WF_CMConnect(iwconfigCb.cpId);
}
}
}
else if ( (3u <= ARGC) && (strcmppgm2ram((char*)ARGV[2], "adhoc") == 0) )
{
if ( iwconfigCb.isIdle )
{
WF_CASetListRetryCount(ADHOC_RETRY_COUNT);
WF_CPSetNetworkType(iwconfigCb.cpId, WF_ADHOC);
WF_CPSetAdHocBehavior(iwconfigCb.cpId, WF_ADHOC_CONNECT_THEN_START);
WF_CMConnect(iwconfigCb.cpId);
}
else
{
WF_CPGetNetworkType(iwconfigCb.cpId, &networkType);
if (networkType == WF_ADHOC)
{
WFConsolePrintRomStr("Already in the adhoc mode", TRUE);
}
else
{
if (WF_CMDisconnect() != WF_SUCCESS)
{
#if defined(STACK_USE_UART)
putsUART("Disconnect failed. Disconnect is allowed only when module is in connected state\r\n");
#endif
}
WF_CPSetNetworkType(iwconfigCb.cpId, WF_ADHOC);
WF_CMConnect(iwconfigCb.cpId);
}
}
}
else
{
WFConsolePrintRomStr("Unknown parameter", TRUE);
return FALSE;
}
return TRUE;
}
/*******************************************************************************
Function:
void iwconfigDisplayStatus(void)
Summary:
Responds to the user invoking iwconfig with no parameters
Description:
Responds to the user invoking iwconfig with no parameters
Parameters:
None.
Returns:
None
Remarks:
None.
*****************************************************************************/
static void iwconfigDisplayStatus(void)
{
UINT8 *p;
UINT8 tmp;
UINT8 connectionState;
UINT8 cpId;
#if defined(MRF24WG)
char buf[6];
#endif
union
{
struct
{
UINT8 List[WF_CHANNEL_LIST_LENGTH];
UINT8 Num;
} Channel;
UINT8 Domain;
struct
{
UINT8 String[WF_MAX_SSID_LENGTH+1];
UINT8 Len;
} Ssid;
struct
{
UINT8 NetworkType;
} Mode;
struct
{
UINT16 Threshold;
} Rts;
} ws; // workspace
// cpId
{
WFConsolePrintRomStr("\tcpid: ", FALSE);
WFConsolePrintInteger(iwconfigCb.cpId, 'd');
WFConsolePrintRomStr("", TRUE);
}
// channel
{
WF_CAGetChannelList(ws.Channel.List, &ws.Channel.Num);
WFConsolePrintRomStr("\tchannel: ", FALSE);
p = ws.Channel.List;
tmp = ws.Channel.Num;
while ( --tmp > 0u )
{
WFConsolePrintInteger(*p, 'd');
WFConsolePrintRomStr(",", FALSE);
p++;
}
WFConsolePrintInteger(*p, 'd');
WFConsolePrintRomStr("", TRUE);
}
#if defined(MRF24WG)
// domain
{
WF_GetRegionalDomain(&ws.Domain);
WFConsolePrintRomStr("\tdomain: ", FALSE);
if ( ws.Domain == WF_DOMAIN_FCC )
{
WFConsolePrintRomStr("fcc", TRUE);
}
else if ( ws.Domain == WF_DOMAIN_ETSI )
{
WFConsolePrintRomStr("etsi", TRUE);
}
else if ( ws.Domain == WF_DOMAIN_JAPAN )
{
WFConsolePrintRomStr("japan", TRUE);
}
else if ( ws.Domain == WF_DOMAIN_OTHER )
{
WFConsolePrintRomStr("other", TRUE);
}
else
{
WFConsolePrintRomStr("unknown", TRUE);
}
}
#else
// domain
{
WF_GetRegionalDomain(&ws.Domain);
WFConsolePrintRomStr("\tdomain: ", FALSE);
if ( ws.Domain == WF_DOMAIN_FCC )
{
WFConsolePrintRomStr("fcc", TRUE);
}
else if ( ws.Domain == WF_DOMAIN_IC )
{
WFConsolePrintRomStr("ic", TRUE);
}
else if ( ws.Domain == WF_DOMAIN_ETSI )
{
WFConsolePrintRomStr("etsi", TRUE);
}
else if ( ws.Domain == WF_DOMAIN_SPAIN )
{
WFConsolePrintRomStr("spain", TRUE);
}
else if ( ws.Domain == WF_DOMAIN_FRANCE )
{
WFConsolePrintRomStr("france", TRUE);
}
else if ( ws.Domain == WF_DOMAIN_JAPAN_A )
{
WFConsolePrintRomStr("japana", TRUE);
}
else if ( ws.Domain == WF_DOMAIN_JAPAN_B )
{
WFConsolePrintRomStr("japanb", TRUE);
}
else
{
WFConsolePrintRomStr("unknown", TRUE);
}
}
#endif
// rts
{
WF_GetRtsThreshold(&ws.Rts.Threshold);
WFConsolePrintRomStr("\trts: ", FALSE);
WFConsolePrintInteger(ws.Rts.Threshold, 'd');
WFConsolePrintRomStr("", TRUE);
}
// mode
{
WF_CMGetConnectionState(&connectionState, &cpId);
WF_CPGetNetworkType(iwconfigCb.cpId, &ws.Mode.NetworkType);
WFConsolePrintRomStr("\tmode: ", FALSE);
if (iwconfigCb.isIdle)
{
if (iwconfigCb.connState == WF_CSTATE_NOT_CONNECTED)
{
WFConsolePrintRomStr("idle", TRUE);
}
else if (iwconfigCb.connState == WF_CSTATE_CONNECTION_PERMANENTLY_LOST)
{
WFConsolePrintRomStr("idle (connection permanently lost)", TRUE);
}
else
{
WFConsolePrintRomStr("idle (?)", TRUE);
}
}
else
{
WF_CPGetNetworkType(iwconfigCb.cpId, &ws.Mode.NetworkType);
if (ws.Mode.NetworkType == WF_INFRASTRUCTURE)
{
if (iwconfigCb.connState == WF_CSTATE_CONNECTION_IN_PROGRESS)
{
WFConsolePrintRomStr("managed (connection in progress)", TRUE);
}
else if (iwconfigCb.connState == WF_CSTATE_CONNECTED_INFRASTRUCTURE)
{
WFConsolePrintRomStr("managed", TRUE);
}
else if (iwconfigCb.connState == WF_CSTATE_RECONNECTION_IN_PROGRESS)
{
WFConsolePrintRomStr("managed (reconnection in progress)", TRUE);
}
else
{
WFConsolePrintRomStr("managed (?)", TRUE);
}
}
else if (ws.Mode.NetworkType == WF_ADHOC)
{
if (iwconfigCb.connState == WF_CSTATE_CONNECTION_IN_PROGRESS)
{
WFConsolePrintRomStr("adhoc (connection in progress)", TRUE);
}
else if (iwconfigCb.connState == WF_CSTATE_CONNECTED_ADHOC)
{
WFConsolePrintRomStr("adhoc", TRUE);
}
else if (iwconfigCb.connState == WF_CSTATE_RECONNECTION_IN_PROGRESS)
{
WFConsolePrintRomStr("adhoc (reconnection in progress)", TRUE);
}
else
{
WFConsolePrintRomStr("adhoc (?)", TRUE);
}
}
else
{
WFConsolePrintRomStr("unknown", TRUE);
}
}
}
// ssid
{
WF_CPGetSsid(iwconfigCb.cpId, ws.Ssid.String, &ws.Ssid.Len);
ws.Ssid.String[ws.Ssid.Len] = '\0';
WFConsolePrintRomStr("\tssid: ", FALSE);
WFConsolePrintRamStr(ws.Ssid.String, TRUE);
}
// power
{
switch (iwconfigCb.powerSaveState)
{
case WF_PS_PS_POLL_DTIM_ENABLED:
WFConsolePrintRomStr("\tpwrsave: enabled", TRUE);
WFConsolePrintRomStr("\tdtim rx: enabled", TRUE);
break;
case WF_PS_PS_POLL_DTIM_DISABLED:
WFConsolePrintRomStr("\tpwrsave: enabled", TRUE);
WFConsolePrintRomStr("\tdtim rx: disabled", TRUE);
break;
case WF_PS_OFF:
WFConsolePrintRomStr("\tpwrsave: disabled", TRUE);
break;
default:
WFConsolePrintRomStr("\tpwrsave: unknown(", FALSE);
WFConsolePrintInteger(iwconfigCb.powerSaveState, 'd');
WFConsolePrintRomStr(")", TRUE);
break;
}
}
#if defined(MRF24WG)
// context
WF_OutputConnectionContext();
// Network Type
putrsUART("\tNetwork: ");
#if defined(EZ_CONFIG_STORE) && !defined(WF_CONSOLE_DEMO) /* if EZConfig demo */
if (AppConfig.networkType == WF_ADHOC)
{
putrsUART("AdHoc\r\n");
}
else
{
putrsUART("Infrastructure\r\n");
}
#else
#if (MY_DEFAULT_NETWORK_TYPE == WF_ADHOC)
putrsUART("AdHoc\r\n");
#elif (MY_DEFAULT_NETWORK_TYPE == WF_P2P)
putrsUART("P2P\r\n");
#elif (MY_DEFAULT_NETWORK_TYPE == WF_INFRASTRUCTURE)
#if (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPS_PUSH_BUTTON)
putrsUART("Infrastructure (using WPS Push Button)\r\n");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPS_PIN)
putrsUART("Infrastructure (using WPS Pin)\r\n");
#else
putrsUART("Infrastructure\r\n");
#endif
#endif
#endif /* EZ_CONFIG_STORE */
// Retry Count
putrsUART("\tRetries ");
#if (MY_DEFAULT_NETWORK_TYPE == WF_ADHOC)
sprintf(buf, "%d\r\n", ADHOC_RETRY_COUNT);
putsUART(buf);
#elif (MY_DEFAULT_NETWORK_TYPE == WF_INFRASTRUCTURE)
#if (INFRASTRUCTURE_RETRY_COUNT == WF_RETRY_FOREVER)
sprintf(buf, "Retry Forever\r\n");
putsUART(buf);
#else
sprintf(buf, "%d\r\n", INFRASTRUCTURE_RETRY_COUNT);
putsUART(buf);
#endif
#endif /* (MY_DEFAULT_NETWORK_TYPE == WF_ADHOC) */
// Security
putrsUART("\tSecurity: ");
#if (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_OPEN)
putrsUART("WF_SECURITY_OPEN");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WEP_40)
putrsUART("WF_SECURITY_WEP_40");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WEP_104)
putrsUART("WF_SECURITY_WEP_104");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA_WITH_KEY)
putrsUART("WF_SECURITY_WPA_WITH_KEY");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA_WITH_PASS_PHRASE)
putrsUART("WF_SECURITY_WPA_WITH_PASS_PHRASE");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA2_WITH_KEY)
putrsUART("WF_SECURITY_WPA2_WITH_KEY");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA2_WITH_PASS_PHRASE)
putrsUART("WF_SECURITY_WPA2_WITH_PASS_PHRASE");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA_AUTO_WITH_KEY)
putrsUART("WF_SECURITY_WPA_AUTO_WITH_KEY");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA_AUTO_WITH_PASS_PHRASE)
putrsUART("WF_SECURITY_WPA_AUTO_WITH_PASS_PHRASE");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPS_PUSH_BUTTON)
putrsUART("WF_SECURITY_WPS_PUSH_BUTTON");
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPS_PIN)
putrsUART("WF_SECURITY_WPS_PIN");
#else
putrsUART("Unknown");
#endif
putrsUART("\r\n");
// scan type
putrsUART("\tScan: ");
#if (MY_DEFAULT_SCAN_TYPE == WF_ACTIVE_SCAN)
putrsUART("Active Scan\r\n");
#else
putrsUART("Passive Scan\r\n");
#endif
// MAC address
putrsUART("\tMAC: ");
OutputMacAddress();
#endif /* MRF24WG */
}
/*****************************************************************************
Function:
static HTTP_IO_RESULT HTTPPostWifiConfig(void)
Summary:
Processes the wifi config data
Description:
Accepts wireless configuration data from the www site and saves them to a
structure to be applied by the ZG configuration manager.
The following configurations are possible:
i) Mode: adhoc or infrastructure
ii) Security:
- None
- WPA/WPA2 passphrase
- WPA/WPA2 pre-calculated key
- WEP 64-bit
- WEP 128-bit
iii) Key material
If an error occurs, such as data is invalid they will be redirected to a page
informing the user of such results.
NOTE: This code for modified originally from HTTPPostWifiConfig as distributed
by Microchip.
Precondition:
None
Parameters:
None
Return Values:
HTTP_IO_DONE - all parameters have been processed
HTTP_IO_NEED_DATA - data needed by this function has not yet arrived
***************************************************************************/
static HTTP_IO_RESULT HTTPPostWifiConfig(void)
{
// Check to see if the browser is attempting to submit more data than we
// can parse at once. This function needs to receive all updated
// parameters and validate them all before committing them to memory so that
// orphaned configuration parameters do not get written (for example, if a
// static IP address is given, but the subnet mask fails parsing, we
// should not use the static IP address). Everything needs to be processed
// in a single transaction. If this is impossible, fail and notify the user.
// As a web devloper, if you add parameters to AppConfig and run into this
// problem, you could fix this by to splitting your update web page into two
// seperate web pages (causing two transactional writes). Alternatively,
// you could fix it by storing a static shadow copy of AppConfig someplace
// in memory and using it instead of newAppConfig. Lastly, you could
// increase the TCP RX FIFO size for the HTTP server. This will allow more
// data to be POSTed by the web browser before hitting this limit.
UINT8 ConnectionProfileID;
UINT8 ConnectionState;
UINT8 ssidLen;
WF_CMGetConnectionState(&ConnectionState, &ConnectionProfileID);
if(curHTTP.byteCount > TCPIsGetReady(sktHTTP) + TCPGetRxFIFOFree(sktHTTP))
goto ConfigFailure;
// Ensure that all data is waiting to be parsed. If not, keep waiting for
// all of it to arrive.
if(TCPIsGetReady(sktHTTP) < curHTTP.byteCount)
return HTTP_IO_NEED_DATA;
// Read all browser POST data
while(curHTTP.byteCount)
{
// Read a form field name
if(HTTPReadPostName(curHTTP.data, 6) != HTTP_READ_OK)
goto ConfigFailure;
// Read a form field value
if(HTTPReadPostValue(curHTTP.data + 6, sizeof(curHTTP.data)-6-2) != HTTP_READ_OK)
goto ConfigFailure;
// Parse the value that was read
// Read security type
if(!strcmppgm2ram((char*)curHTTP.data, "sec"))
{
char security_type[7];
if (strlen((char*)(curHTTP.data+6)) > 6) /* Sanity check */
goto ConfigFailure;
memcpy(security_type, (void*)(curHTTP.data+6), strlen((char*)(curHTTP.data+6)));
security_type[strlen((char*)(curHTTP.data+6))] = 0; /* Terminate string */
printf("\r\nSecurity Mode: ");
if (!strcmppgm2ram((char*)security_type, "no"))
{
CFGCXT.security = WF_SECURITY_OPEN;
printf("OPEN");
}
else if(!strcmppgm2ram((char*)security_type, "wpa"))
{
CFGCXT.security = WF_SECURITY_WPA_AUTO_WITH_PASS_PHRASE;
printf("WPA w/PASSPHRASE");
}
else if(!strcmppgm2ram((char*)security_type, "calc"))
{ /* Pre-calculated key */
CFGCXT.security = WF_SECURITY_WPA_AUTO_WITH_KEY;
printf("WPA w/AUTO Key");
}
else if(!strcmppgm2ram((char*)security_type, "wep40"))
{
CFGCXT.security = WF_SECURITY_WEP_40;
printf("WEP 64-bit");
}
else if(!strcmppgm2ram((char*)security_type, "wep104"))
{
CFGCXT.security = WF_SECURITY_WEP_104;
printf("WEP 128-bit");
}
else
{ //Security type no good :-(
printf("\r\nUnknown key type!");
goto ConfigFailure;
}
}
// Read new Security Key
/*
else if(!strcmppgm2ram((char*)curHTTP.data, "key"))
{
BYTE key_size = 0, ascii_key = 0;
switch ((BYTE)CFGCXT.security)
{
case WF_SECURITY_OPEN: //keep compiler happy, nothing to do here!
break;
case WF_SECURITY_WPA_AUTO_WITH_PASS_PHRASE: //wpa passphrase
printf("\r\nPassphrase type of key! ");
ascii_key = 1;
key_size = strlen((char *)(curHTTP.data+6));
//between 8-63 characters, passphrase
if ((key_size < 8 ) || (key_size > 63))
goto ConfigFailure;
break;
case WF_SECURITY_WPA_AUTO_WITH_KEY: //wpa pre-calculated key!!!
key_size = 64;
break;
case WF_SECURITY_WEP_40:
key_size = 10; // Assume hex size
if (strlen((char *)(curHTTP.data+6)) == 5) {
key_size = 5; // ASCII key support
ascii_key = 1;
}
CFGCXT.defaultWepKey = 0; // Example uses only key idx 0 (sometimes called 1)
break;
case WF_SECURITY_WEP_104:
key_size = 26; // Assume hex size
if (strlen((char *)(curHTTP.data+6)) == 13) {
key_size = 13; // ASCII key support
ascii_key = 1;
}
CFGCXT.defaultWepKey = 0; // Example uses only key idx 0 (sometimes called 1)
break;
default:
break;
}
if (strlen((char *)(curHTTP.data + 6)) != key_size)
{
printf("\r\nIncomplete key received! ");
goto ConfigFailure;
}
memcpy(CFGCXT.key, (void*)(curHTTP.data+6), key_size);
CFGCXT.key[key_size] = 0; // terminate string
if (!ascii_key)
{
//if ((cfg.security == sec_wep64) || (cfg.security == sec_wep128))
key_size /= 2;
if (!convertAsciiToHexInPlace((INT8 *)&CFGCXT.key[0], key_size))
{
printf("\r\nFailed to convert ASCII to hex! ");
goto ConfigFailure;
}
}
}
*/
// Get new ssid and make sure it is valid
else if(!strcmppgm2ram((char*)curHTTP.data, "ssid"))
{
if(strlen((char*)(curHTTP.data+6)) < 33u)
{
memcpy(CFGCXT.ssid, (void*)(curHTTP.data+6), strlen((char*)(curHTTP.data+6)));
CFGCXT.ssid[strlen((char*)(curHTTP.data+6))] = 0; /* Terminate string */
/* save current profile SSID for displaying later */
WF_CPGetSsid(ConnectionProfileID, (UINT8*)&CFGCXT.prevSSID, &ssidLen);
CFGCXT.prevSSID[ssidLen] = 0;
printf("\r\nSSID: %s",CFGCXT.ssid);
}
else
{ //Invalid SSID... fail :-(
printf("\r\nInvalid SSID...! ");
goto ConfigFailure;
}
}
// Get the wlan mode: adhoc or infrastructure
else if(!strcmppgm2ram((char*)curHTTP.data, (ROM char*)"wlan"))
{
char mode[6];
if (strlen((char*)(curHTTP.data+6)) > 5) /* Sanity check */
goto ConfigFailure;
memcpy(mode, (void*)(curHTTP.data+6), strlen((char*)(curHTTP.data+6)));
mode[strlen((char*)(curHTTP.data+6))] = 0; /* Terminate string */
if(!strcmppgm2ram((char*)mode, (ROM char*)"infra"))
{
printf("\r\nSetting mode to infrastructure! ");
CFGCXT.type = WF_INFRASTRUCTURE;
}
else if(!strcmppgm2ram((char*)mode, "adhoc"))
{
printf("\r\nSetting mode to adhoc! ");
CFGCXT.type = WF_ADHOC;
// Always setup adhoc to attempt to connect first, then start
WF_CPSetAdHocBehavior(ConnectionProfileID, WF_ADHOC_CONNECT_THEN_START);
}
else
{ //Mode type no good :-(
printf("\r\nConfig WLAN Mode Failure! ");
goto ConfigFailure;
}
// save old WLAN mode
WF_CPGetNetworkType(ConnectionProfileID, &CFGCXT.prevWLAN);
}
}
/* Check if WPA hasn't been selected with adhoc, if it has we choke! */
if ((CFGCXT.type == WF_ADHOC) &&
((CFGCXT.security == WF_SECURITY_WPA_AUTO_WITH_PASS_PHRASE) || (CFGCXT.security == WF_SECURITY_WPA_AUTO_WITH_KEY)))
goto ConfigFailure;
/*
* All parsing complete! If we have got to here all data has been validated and
* we can handle what is necessary to start the reconfigure process of the WiFi device
*/
// Copy wifi cfg data to be committed
memcpy(CPElements.ssid, CFGCXT.ssid, strlen((char*)(CFGCXT.ssid)));
CPElements.ssidLength = strlen((char*)(CFGCXT.ssid));
/* Going to set security type */
CPElements.securityType = CFGCXT.security;
/* Going to save the key, if required */
if (CFGCXT.security != WF_SECURITY_OPEN)
{
BYTE key_size =0;
switch ((BYTE)CFGCXT.security)
{
case WF_SECURITY_WPA_AUTO_WITH_PASS_PHRASE: //wpa passphrase
key_size = strlen((char*)(CFGCXT.key)); //ascii so use strlen
break;
case WF_SECURITY_WPA_AUTO_WITH_KEY: //wpa pre-calculated key!!!
key_size = 32;
break;
case WF_SECURITY_WEP_40:
key_size = 5;
break;
case WF_SECURITY_WEP_104:
key_size = 13;
break;
}
memcpy(CPElements.securityKey, CFGCXT.key, key_size);
CPElements.securityKey[strlen((char*)(CFGCXT.key))] = 0;
}
/* Going to save the network type */
CPElements.networkType = CFGCXT.type;
// Set the board to reboot and display reconnecting information
strcpypgm2ram((char*)curHTTP.data, "/reconnect.htm");
curHTTP.httpStatus = HTTP_REDIRECT;
/*
* Set state here to inform that the Wifi device has config data and it is ready
* to be acted upon.
*/
printf("\r\nFlagging to start config change!\r\n");
WF_START_EASY_CONFIG();
return HTTP_IO_DONE;
ConfigFailure:
//!lastFailure = TRUE;
strcpypgm2ram((char*)curHTTP.data, "/error.htm");
curHTTP.httpStatus = HTTP_REDIRECT;
return HTTP_IO_DONE;
}
