tZGVoidReturn
adHocConnStartComplete(tZGU8 type, tZGDataPtr fourByteHeader, tZGDataPtr pBuf,
tZGU16 len, tZGVoidInput *appOpaquePtr)
{
tZGU8 result = fourByteHeader[0];
APPCXT.FSM.stateStatus= kFAILURE;
if(result == (tZGU8)kZGResultSuccess)
{
ZG_PUTRSUART(" succeeded\n\r");
APPCXT.bConnected = kZGBoolTrue;
APPCXT.FSM.stateStatus= kSUCCESS;
/* Enable link up/down indicates */
if ( !ZGLibEnableIndicate( ZG_INDICATE_HANDLE(genericIndicate), kZGBoolTrue) )
{
ZGSYS_MODULE_ASSERT(1, (ROM FAR char*) "Enable link up/down\n\r");
}
#ifdef ZG_CONFIG_STATIC_IP
printIPAddr();
#endif
}
else
{
ZG_PUTRSUART(" failed\n\r");
}
}
tZGVoidReturn
adHocDisconnComplete(tZGU8 type, tZGDataPtr fourByteHeader, tZGDataPtr pBuf,
tZGU16 len, tZGVoidInput *appOpaquePtr)
{
APPCXT.FSM.stateStatus= kSUCCESS;
/* Disable link up/down indicates */
if ( !ZGLibEnableIndicate( ZG_INDICATE_HANDLE(genericIndicate), kZGBoolFalse) )
{
ZGSYS_MODULE_ASSERT(1, (ROM FAR char*) "Error Disable indicate\n\r");
}
ZG_PUTRSUART(" succeeded\n\r");
}
tZGVoidReturn
ZGLinkMgrSetMode( tZGLMNetworkMode mode )
{
APPCXT.FSM.currentMode = mode;
switch ( mode )
{
case kZGLMNetworkModeIdle:
APPCXT.FSMSelector = g_emptyFSM;
break;
#if !defined (ZG_CONFIG_NO_WIFIMGRII)
case kZGLMNetworkModeInfrastructure:
APPCXT.FSMSelector = g_mangedFSM;
break;
#endif
#if !defined (ZG_CONFIG_NO_ADHOCMGRII)
case kZGLMNetworkModeAdhoc:
APPCXT.FSMSelector = g_adhocFSM;
break;
#endif /* ADHOC MODE */
default:
ZGSYS_MODULE_ASSERT(1, (ROM FAR char*) "BAD MODE");
}
APPCXT.FSM.stateStatus = kSUCCESS;
APPCXT.FSM.currentState = kSTIdle;
APPCXT.bRetryBSSConnect = kZGBoolTrue;
APPCXT.nJoinRetryState = 0;
APPCXT.nRetryBSSConnect = 0;
APPCXT.nAssocRetryState = 0;
APPCXT.nAuthRetryState = 0;
APPCXT.nScanRetryState = 0;
}
enum tFSMValidStates
adHocDomNextState( tZGVoidInput )
{
enum tFSMValidStates nextState = kSTIdle;
if ( APPCXT.FSM.stateStatus != kFAILURE )
{
switch ( ZG_GET_ENC_TYPE() )
{
case kKeyTypeWep:
nextState = kSTInstallWEPKey;
break;
case kKeyTypeCalcPsk:
case kKeyTypePsk:
nextState = kSTIdle;
ZG_SETNEXT_MODE( kZGLMNetworkModeIdle );
#if defined ( ZG_CONFIG_CONSOLE )
ZG_PUTRSUART("PSK/WPA not supported in AdHoc mode.\n\r");
#endif
break;
case kKeyTypeNone:
nextState = kSTScan;
break;
default:
ZGSYS_MODULE_ASSERT(1, (ROM FAR char*) "Unknown security encryption type");
break;
}
}
return nextState;
}
tZGU8
adHocStartRequest( void * const ptrRequest, tZGVoidInput *appOpaquePtr)
{
tZGAdhocStartReqPtr ptrStart = (tZGAdhocStartReqPtr)ptrRequest;
/* choose the first channel in ordered list for network start */
if ( ZG_GET_ACTIVE_CHANNELS() == 0u )
{
ZGSYS_MODULE_ASSERT(1, (ROM FAR char *)"Adhoc StartReq: empty channel list\n\r");
}
else
ptrStart->channel = ZG_CHANNEL(0);
ptrStart->beaconPrd = HSTOZGS( (tZGU16) 100);
ptrStart->capInfo[0] = kZGAdhocMgrCapBitIbss; /* was | kZGAdhocMgrCapBitShortPreamble; 0x22 */
/* If in WEP mode, set the corresponding bit. */
if ( ZG_GET_ENC_TYPE() == (tZGU8)kKeyTypeWep )
{
ptrStart->capInfo[0] = ptrStart->capInfo[0] | kZGAdhocMgrCapBitPrivacy;
}
ptrStart->capInfo[1] = 0;
ptrStart->ssidLen = ZG_SSID_LEN();
memcpy( (void *) ptrStart->ssid, (const void*) ZG_GET_SSID(), ptrStart->ssidLen);
/* These values are part of the adhoc network beacon */
/* and are part of the "basic rate" set, not to be */
/* confused with supported rate set */
ptrStart->dataRateLen = 2;
ptrStart->dataRates[0] = 0x82; /* 1Mbps */
ptrStart->dataRates[1] = 0x84; /* 2Mbps */
ZG_PUTRSUART("Start ...\n\r");
return ( sizeof(tZGAdhocStartReq) );
}
/*****************************************************************************
* FUNCTION: do_iwpriv_cmd
*
* RETURNS: None
*
* PARAMS: None
*
* NOTES: Responds to the user invoking ifconfig
*****************************************************************************/
tZGVoidReturn do_iwpriv_cmd(tZGVoidInput)
{
tZGU8 i;
tZGU8 temp;
tZGBool cont_parse;
tZGS8* ptrString;
gLineParseState = kZGWaitingForParamKeyword;
// if user only typed in iwpriv with no other parameters
if (ARGC == 1u)
{
IwprivDisplayStatus();
}
// else loop through each parameter
else
{
// parse each param and set state variables
for (i = 1; i < ARGC; ++i)
{
switch (gLineParseState)
{
case kZGWaitingForParamKeyword:
if ( !getParam(i) )
{
return;
}
break;
case kZGWaitingForWpaPsk:
/* Can only set security in idle state */
if ( ZG_IS_CONNECTED() == kZGBoolTrue )
{
ZG_PUTRSUART("Security context may only be set in idle state\n\r");
return;
}
/* The ARGV buffer is modified in place */
if ( !ExtractandValidateWpaPSK( ARGV[i] ) )
{
ZG_PUTRSUART("WPA PSK must be exactly 64 bytes\n\r");
return;
}
ZG_SET_WPAPSK( (tZGU8Ptr) ARGV[i] );
gLineParseState = kZGWaitingForParamKeyword;
break;
case kZGWaitingForWpaStr:
/* Can only set security in idle state */
if ( ZG_IS_CONNECTED() == kZGBoolTrue )
{
ZG_PUTRSUART("Security context may only be set in idle state\n\r");
return;
}
ptrString = ARGV[i++];
/* if the start char is found, gobble that char */
if ( (cont_parse = ExtractWpaStrStart(ptrString)) == kZGBoolTrue)
{
ptrString++;
}
/* this code concats tokens together with whitespace */
/* until no more tokens or the EOS " char is found */
while ( cont_parse && (i++ < ARGC))
{
cont_parse = ExtractWpaStrEnd( ptrString );
}
/* if the EOS char is not found then cont parse is true */
if (cont_parse)
{
ZG_PUTRSUART("Passphrase missing EOS '\"' \n\r");
return;
}
/* temp contains the string length after call */
if ( !ValidateWpaStr(&ptrString, &temp) )
{
ZG_PUTRSUART("Passphrase must be between 8 and 63 chars\n\r");
return;
}
ZG_SET_WPA_PASSPHRASE( ptrString, temp );
gLineParseState = kZGWaitingForParamKeyword;
break;
case kZGWaitingForEnc:
/* Can only set security in idle state */
if ( ZG_IS_CONNECTED() == kZGBoolTrue )
{
ZG_PUTRSUART("Security context may only be set in idle state\n\r");
return;
}
/* temp contains the encryption type enum */
if ( !ExtractandValidateEncType(ARGV[i], &temp) )
{
ZG_PUTRSUART("Invalid encyption type\n\r");
return;
}
ZG_SET_ENC_TYPE( temp );
gLineParseState = kZGWaitingForParamKeyword;
break;
case kZGWaitingForWepAuth:
/* Can only set security in idle state */
if ( ZG_IS_CONNECTED() == kZGBoolTrue )
{
ZG_PUTRSUART("Security context may only be set in idle state\n\r");
return;
}
/* temp contains the Wep Auth type enum */
if ( !ExtractandValidateAuthType(ARGV[i], &temp) )
{
ZG_PUTRSUART("Invalid WEP Auth type\n\r");
return;
}
ZG_SET_AUTH_TYPE( temp );
gLineParseState = kZGWaitingForParamKeyword;
break;
case kZGWaitingForWepKey:
/* Can only set security in idle state */
if ( ZG_IS_CONNECTED() == kZGBoolTrue )
{
ZG_PUTRSUART("Security context may only be set in idle state\n\r");
return;
}
/* temp contains the active WEP key index 1 of 4 */
if ( !ExtractandValidateWepIndex(ARGV[i], &temp) )
{
ZG_PUTRSUART("Invalid WEP key index\n\r");
return;
}
/* check for a 3rd optional parameter */
if ( (i+1 < ARGC) &&
(getParamType(ARGV[i+1]) == kZGUnknownParam) )
{
i++; /* advance to the optional param */
/* The ARGV buffer is modified in place */
if ( ExtractandValidateWepLong( ARGV[i] ) )
{
ZG_SET_WEP_KEY_LONG( (tZGU8Ptr) ARGV[i], temp );
}
else if ( ExtractandValidateWepShort( ARGV[i] ) )
{
ZG_SET_WEP_KEY_SHORT( (tZGU8Ptr) ARGV[i], temp );
}
else
{
ZG_PUTRSUART("\n\rWarning, 64/128bit WEP key format not valid \n\r\t");
return;
}
}
ZG_SET_WEP_ACTIVE_INDEX(temp);
gLineParseState = kZGWaitingForParamKeyword;
break;
default:
ZGSYS_MODULE_ASSERT(2, (ROM FAR char*)"iwpriv param");
break;
} // end switch
} // end for
}
switch (gLineParseState)
{
case kZGWaitingForBeacon:
// Send an untampered frame that looks like a Beacon.
iwpriv_beacon();
gLineParseState = kZGWaitingForParamKeyword;
break;
default:
//do nothing
break;
}
if (gLineParseState != (tZGU8)kZGWaitingForParamKeyword)
{
ZG_PUTRSUART("Missing value after last parameter\n\r");
}
}
void
ZGLinkMgr(void)
{
tDispatchZGLib appLibFuncPtr = kNULL;
tDispatchComplete appCompleteHandler = kNULL;
tDispatchRequest appRequestHandler = kNULL;
tDispatchNext appNextStateHandler = APPCXT.FSMSelector[APPCXT.FSM.currentState].next_state_func;
enum tFSMValidStates tempNext = kNULL;
/* This is an optional runtime override to the static pass/fail next states in a FSM table */
/* The next state is useful when the decission process for a next state is based on random user input */
/* or there are multiple edges to the next state in the FSM graph */
if ( appNextStateHandler != kNULL )
{
/* If the nextState handler returns null, it does not want to override */
tempNext = DISPATCH_NEXT(appNextStateHandler);
}
switch ( APPCXT.FSM.stateStatus )
{
case kSUCCESS:
/* Does the next state hander have a runtime overide? of the static pass entry */
if ( tempNext != kNULL )
APPCXT.FSM.currentState = tempNext;
else
APPCXT.FSM.currentState = APPCXT.FSMSelector[ APPCXT.FSM.currentState ].next_success;
break;
case kFAILURE:
/* Does the next state hander have a runtime overide? of the static fail entry */
if ( tempNext != kNULL )
APPCXT.FSM.currentState = tempNext;
else
/* The pass or fail next states are defined in FSM tables */
APPCXT.FSM.currentState = APPCXT.FSMSelector[ APPCXT.FSM.currentState ].next_fail;
break;
case kRETRY:
/* call the same state again */
break;
case kPENDING:
/* wait for driver to complete call*/
return;
default:
ZGSYS_MODULE_ASSERT(1, (ROM FAR char*) "Unknown FSM status\n\r");
break;
}
appLibFuncPtr = APPCXT.FSMSelector[APPCXT.FSM.currentState].zg_library_func;
if ( appLibFuncPtr != kNULL )
{
/* iniate the call to the ZeroG library */
appCompleteHandler = APPCXT.FSMSelector[APPCXT.FSM.currentState].complete_func;
appRequestHandler = APPCXT.FSMSelector[APPCXT.FSM.currentState].request_func;
g_linkMgrCtx.FSM.stateStatus = kPENDING;
/* This call can fail, if another library call has been made or there is no memory for a new call */
if ( DISPATCH_ZGLIB (appLibFuncPtr, appRequestHandler, appCompleteHandler, kNULL) != kZGSuccess )
g_linkMgrCtx.FSM.stateStatus = kRETRY;
}
} /* end switch */
