uint32_t AutoIPRand(NET_CONFIG* pNet)
{
LoadState(_TCPIPStackNetIx(pNet));
LFSRSeedRand(AutoIPClient.wRandSeed);
AutoIPClient.wRandSeed = LFSRRand();
return AutoIPClient.wRandSeed;
}
DWORD AutoIPRand (BYTE vInterface)
{
LoadState (vInterface);
LFSRSeedRand(AutoIPClient.wRandSeed);
AutoIPClient.wRandSeed = LFSRRand();
return AutoIPClient.wRandSeed;
}
/*****************************************************************************
Function:
uint32_t SYS_GENERATE_RANDOM_DWORD(void)
Summary:
Generates a random uint32_t.
Description:
This function generates a random 32-bit integer. It collects
randomness by comparing the A/D converter's internal R/C oscillator
clock with our main system clock. By passing collected entropy to the
LFSRSeedRand()/LFSRRand() functions, the output is normalized (deskewed)
in the hopes of meeting statistical randomness tests.
Precondition:
None
Parameters:
None
Returns:
Random 32-bit number.
Side Effects:
This function uses the A/D converter (and so you must disable
interrupts if you use the A/D converted in your ISR). The LFSRRand()
function will be reseeded, and Timer1 (PIC24,
dsPIC, and PIC32) will be used. TMR#H:TMR#L will have a new value.
Note that this is the same timer used by the Tick module.
Remarks:
This function times out after 1 second of attempting to generate the
random uint32_t. In such a case, the output may not be truly random.
Typically, this function executes in around 500,000 instruction cycles.
The intent of this function is to produce statistically random and
cryptographically secure random number. Whether or not this is true on
all (or any) devices/voltages/temperatures is not tested.
***************************************************************************/
uint32_t SYS_GENERATE_RANDOM_DWORD(void)
{
uint8_t vBitCount;
uint16_t w, wTime, wLastValue;
uint32_t dwTotalTime;
union
{
uint32_t dw;
uint16_t w[2];
} randomResult;
uint16_t AD1CON1Save, AD1CON2Save, AD1CON3Save;
uint16_t T1CONSave, PR1Save;
// Save hardware SFRs
AD1CON1Save = AD1CON1;
AD1CON2Save = AD1CON2;
AD1CON3Save = AD1CON3;
T1CONSave = T1CON;
PR1Save = PR1;
// Set up Timer and A/D converter module
AD1CON1 = 0x0000; // Turn off the ADC so we can write to it
AD1CON3 = 0x9F00; // Frc A/D clock, 31 Tad acquisition
AD1CON2 = 0x003F; // Interrupt after every 16th sample/convert
AD1CON1 = 0x80E4; // Turn on the A/D module, auto-convert
T1CON = 0x8000; // TON = 1, no prescalar
PR1 = 0xFFFF; // Don't clear timer early
vBitCount = 0;
dwTotalTime = 0;
wLastValue = 0;
randomResult.dw = LFSRRand();
while(1)
{
SYS_WDT_Clear();
#if defined(__C30__)
while(!IFS0bits.AD1IF);
#else
while(!IFS1bits.AD1IF);
#endif
wTime = TMR1;
TMR1 = 0x0000;
#if defined(__C30__)
IFS0bits.AD1IF = 0;
#else
IFS1CLR = _IFS1_AD1IF_MASK;
#endif
w = LFSRRand();
// Wait no longer than 1 second obtaining entropy
dwTotalTime += wTime;
if(dwTotalTime >= SYS_CLK_ClockGet())
{
randomResult.w[0] ^= LFSRRand();
randomResult.w[1] ^= LFSRRand();
break;
}
// Keep sampling if minimal entropy was likely obtained this round
if(wLastValue == wTime)
continue;
// Add this entropy into the pseudo random number generator by reseeding
LFSRSeedRand(w + (wLastValue - wTime));
wLastValue = wTime;
// Accumulate at least 32 bits of randomness over time
randomResult.dw <<= 1;
if(LFSRRand() & 0x0080)
randomResult.w[0] |= 0x1;
// See if we've collected a fair amount of entropy and can quit early
if(++vBitCount == 0u)
break;
}
// Restore hardware SFRs
AD1CON1 = 0x0000; // Turn off the ADC so we can write to it
AD1CON3 = AD1CON3Save;
AD1CON2 = AD1CON2Save;
AD1CON1 = AD1CON1Save;
T1CON = T1CONSave;
PR1 = PR1Save;
return randomResult.dw;
}
void AutoIPTasks(NET_CONFIG* pConfig)
{
// uint8_t i;
TCPIP_MAC_HANDLE hMac;
// for (i = 0; i < NETWORK_INTERFACES; i++)
{
LoadState(_TCPIPStackNetIx(pConfig));
hMac = _TCPIPStackNetToMac(pConfig);
AutoIPClient.flags.bits.bCurrentLinkState = MACIsLinked(hMac);
if(AutoIPClient.flags.bits.bCurrentLinkState != AutoIPClient.flags.bits.bLastLinkState)
{
AutoIPClient.flags.bits.bLastLinkState = AutoIPClient.flags.bits.bCurrentLinkState;
if(!AutoIPClient.flags.bits.bCurrentLinkState)
{
AutoIPClient.flags.bits.bConfigureAutoIP = false;
AutoIPClient.smAUTOIPState = SM_AUTOIP_DISABLED;
pConfig->MyIPAddr.Val = pConfig->DefaultIPAddr.Val;
pConfig->MyMask.Val = pConfig->DefaultMask.Val;
}
else
{
AutoIPClient.smAUTOIPState = SM_AUTOIP_INIT_RNG;
}
}
#if defined (TCPIP_STACK_USE_DHCP_CLIENT)
if (DHCPIsBound(pConfig))
{
AutoIPClient.flags.bits.bConfigureAutoIP = false;
AutoIPClient.smAUTOIPState = SM_AUTOIP_DISABLED;
AutoIPClient.flags.bits.bLastDHCPState = true;
}
else
{
if (AutoIPClient.flags.bits.bLastDHCPState == true)
{
if (AutoIPClient.flags.bits.bCurrentLinkState)
AutoIPClient.smAUTOIPState = SM_AUTOIP_INIT_RNG;
}
AutoIPClient.flags.bits.bLastDHCPState = false;
}
#endif
if (AutoIPClient.flags.bits.gDisableAutoIP == true)
{
AutoIPClient.flags.bits.bConfigureAutoIP = false;
AutoIPClient.smAUTOIPState = SM_AUTOIP_DISABLED;
}
switch (AutoIPClient.smAUTOIPState)
{
// Default no-AutoIP case
case SM_AUTOIP_DISABLED:
break;
// Initializes the random number generator with a seed based on the MAC address
case SM_AUTOIP_INIT_RNG:
AutoIPRandSeed (((uint32_t)pConfig->MyMACAddr.v[0] + ((uint32_t)pConfig->MyMACAddr.v[1] << 8) + \
((uint32_t)pConfig->MyMACAddr.v[2] << 16) + ((uint32_t)pConfig->MyMACAddr.v[3] << 24) + \
((uint32_t)pConfig->MyMACAddr.v[4]) + ((uint32_t)pConfig->MyMACAddr.v[5] << 8)), pConfig);
AutoIPClient.smAUTOIPState = SM_AUTOIP_CHECK_ADDRESS;
// Check the address to see if it's in use before we write it into NetConfig
case SM_AUTOIP_CHECK_ADDRESS:
if (AutoIPClient.flags.bits.checkAddress == false)
{
AutoIPClient.flags.bits.checkAddress = true;
pConfig->MyMask.Val = 0x00000000;
// Generate a random IP address (based on the MAC address) to try and claim.
// Dynamic link-local addresses can fall within the range:
// 169.254.1.0 - 169.254.254.255
AutoIPClient.packet.TargetIPAddr.byte.MB = AutoIPRand(pConfig) % 256;
AutoIPClient.packet.TargetIPAddr.byte.UB = (AutoIPRand(pConfig) % 254) + 1;
AutoIPClient.packet.TargetIPAddr.word.LW = 0xFEA9;
ARPResolve (pConfig, &AutoIPClient.packet.TargetIPAddr);
AutoIPClient.eventTime = SYS_TICK_Get();
}
if (!ARPIsResolved (pConfig, &AutoIPClient.packet.TargetIPAddr, &AutoIPClient.packet.TargetMACAddr))
{
if (SYS_TICK_Get() - AutoIPClient.eventTime > SYS_TICK_TicksPerSecondGet())
{
AutoIPClient.smAUTOIPState = SM_AUTOIP_SETUP_MESSAGE;
}
}
else
{
AutoIPClient.flags.bits.checkAddress = false;
}
break;
// Set up an ARP packet
case SM_AUTOIP_SETUP_MESSAGE:
AutoIPClient.flags.bits.checkAddress = false;
// Set the bConfigureAutoIP flag- This flag will cause an AutoIP conflict
// if a response packet is received from the address we're trying to claim.
AutoIPClient.flags.bits.bConfigureAutoIP = true;
// Configure the fields for a gratuitous ARP packet
AutoIPClient.packet.Operation = ARP_OPERATION_REQ;
AutoIPClient.packet.TargetMACAddr.v[0] = 0xff;
AutoIPClient.packet.TargetMACAddr.v[1] = 0xff;
AutoIPClient.packet.TargetMACAddr.v[2] = 0xff;
AutoIPClient.packet.TargetMACAddr.v[3] = 0xff;
AutoIPClient.packet.TargetMACAddr.v[4] = 0xff;
AutoIPClient.packet.TargetMACAddr.v[5] = 0xff;
pConfig->MyIPAddr = AutoIPClient.packet.TargetIPAddr;
pConfig->MyMask.Val = 0x0000FFFF;
memcpy(&AutoIPClient.packet.SenderMACAddr, (void*)&pConfig->MyMACAddr, sizeof(AutoIPClient.packet.SenderMACAddr));
AutoIPClient.packet.HardwareType = HW_ETHERNET;
AutoIPClient.packet.Protocol = ARP_IP;
AutoIPClient.packet.MACAddrLen = sizeof(MAC_ADDR);
AutoIPClient.packet.ProtocolLen = sizeof(IP_ADDR);
AutoIPClient.packet.SenderIPAddr.Val = AutoIPClient.packet.TargetIPAddr.Val;
SwapARPPacket(&AutoIPClient.packet);
// Generate a random delay between 0 and 1 second
AutoIPClient.randomDelay = ((LFSRRand() % 20) * SYS_TICK_TicksPerSecondGet()) / 20;
// Store the current time
AutoIPClient.eventTime = SYS_TICK_Get();
// Set the state to send the ARP packet
AutoIPClient.smAUTOIPState = SM_AUTOIP_GRATUITOUS_ARP1;
break;
// Send a gratuitous ARP packet to try and claim our address
case SM_AUTOIP_GRATUITOUS_ARP1:
case SM_AUTOIP_GRATUITOUS_ARP2:
case SM_AUTOIP_GRATUITOUS_ARP3:
// Check to ensure we've passed the delay time
if (SYS_TICK_Get() - AutoIPClient.eventTime > AutoIPClient.randomDelay)
{
if(!MACIsTxReady(hMac))
{
break;
}
// Store the new event time
AutoIPClient.eventTime = SYS_TICK_Get();
// Generate a new random delay between 1 and 2 seconds
AutoIPClient.randomDelay = SYS_TICK_TicksPerSecondGet() + (((LFSRRand() % 20) * SYS_TICK_TicksPerSecondGet()) / 20);
// Transmit the packet
MACSetWritePtr(hMac, MACGetTxBaseAddr(hMac));
MACPutHeader(hMac, &AutoIPClient.packet.TargetMACAddr, ETHERTYPE_ARP, sizeof(AutoIPClient.packet));
MACPutArray(hMac, (uint8_t*)&AutoIPClient.packet, sizeof(AutoIPClient.packet));
MACFlush(hMac);
// Increment the probe iteration or increment to the delay state
AutoIPClient.smAUTOIPState++;
}
break;
// Delay for 1-2 seconds after sending the third ARP request before
// entering the configured state
case SM_AUTOIP_DELAY:
if (SYS_TICK_Get() - AutoIPClient.eventTime > AutoIPClient.randomDelay)
AutoIPClient.smAUTOIPState = SM_AUTOIP_CONFIGURED;
break;
// Configure the module to limit the rate at which packets are sent
case SM_AUTOIP_RATE_LIMIT_SET:
AutoIPClient.eventTime = SYS_TICK_Get();
pConfig->MyIPAddr.Val = pConfig->DefaultIPAddr.Val;
AutoIPClient.smAUTOIPState = SM_AUTOIP_RATE_LIMIT_WAIT;
break;
// Ensure that we don't try more than one address every 60 seconds
case SM_AUTOIP_RATE_LIMIT_WAIT:
if (SYS_TICK_Get() - AutoIPClient.eventTime > SYS_TICK_TicksPerSecondGet() * 60)
AutoIPClient.smAUTOIPState = SM_AUTOIP_CHECK_ADDRESS;
break;
// Configured state
case SM_AUTOIP_CONFIGURED:
AutoIPClient.flags.bits.bConfigureAutoIP = false;
break;
// Address defense state
case SM_AUTOIP_DEFEND:
// Prepare and send an ARP response
if(!MACIsTxReady(hMac))
{
break;
}
AutoIPClient.packet.Operation = ARP_OPERATION_RESP;
AutoIPClient.packet.HardwareType = HW_ETHERNET;
AutoIPClient.packet.Protocol = ARP_IP;
SwapARPPacket(&AutoIPClient.packet);
MACSetWritePtr(hMac, MACGetTxBaseAddr(hMac));
MACPutHeader(hMac, &AutoIPClient.packet.TargetMACAddr, ETHERTYPE_ARP, sizeof(AutoIPClient.packet));
MACPutArray(hMac, (uint8_t*)&AutoIPClient.packet, sizeof(AutoIPClient.packet));
MACFlush(hMac);
AutoIPClient.smAUTOIPState = SM_AUTOIP_CONFIGURED;
break;
}
}
}
