Exemple #1
0
uint32_t AutoIPRand(NET_CONFIG* pNet)
{
	LoadState(_TCPIPStackNetIx(pNet));
    LFSRSeedRand(AutoIPClient.wRandSeed);
    AutoIPClient.wRandSeed = LFSRRand();
    return AutoIPClient.wRandSeed;
}
Exemple #2
0
DWORD AutoIPRand (BYTE vInterface)
{
    LoadState (vInterface);
    LFSRSeedRand(AutoIPClient.wRandSeed);
    AutoIPClient.wRandSeed = LFSRRand();
    return AutoIPClient.wRandSeed;
}
Exemple #3
0
void EthernetInit(void)
{
	// Initialize hardware
	InitBoard();

    // Initialize stack-related hardware components that may be 
    // required by the UART configuration routines
    TickInit();

    // Initialize Stack and application related NV variables into AppConfig.
    InitAppConfig();

	// Seed the LFSRRand() function.
	LFSRSeedRand(GenerateRandomDWORD());

	// Initialize the MAC library.
    MACInit();

	// Initialize the ARP library.
    ARPInit();

	// Initialize UDP.
    UDPInit();

	// Open up a socket for our UDP server.
	localServerSocket = UDPOpenEx(NULL, UDP_OPEN_SERVER, UDP_SERVER_PORT, UDP_SERVER_PORT);
	if (localServerSocket == INVALID_UDP_SOCKET) {
		FATAL_ERROR();
	}

	// Open up a socket for our UDP client.
	remoteServerSocket = UDPOpenEx(NULL, UDP_OPEN_IP_ADDRESS, UDP_CLIENT_PORT, UDP_CLIENT_PORT);
	if (remoteServerSocket == INVALID_UDP_SOCKET) {
		FATAL_ERROR();
	}
}
Exemple #4
0
/*********************************************************************
 * Function:        void StackInit(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          Stack and its componets are initialized
 *
 * Side Effects:    None
 *
 * Note:            This function must be called before any of the
 *                  stack or its component routines are used.
 *
 ********************************************************************/
void StackInit(void)
{
    smStack                     = SM_STACK_IDLE;

#if defined(STACK_USE_IP_GLEANING) || defined(STACK_USE_DHCP_CLIENT)
    /*
     * If DHCP or IP Gleaning is enabled,
     * startup in Config Mode.
     */
    AppConfig.Flags.bInConfigMode = TRUE;

#endif

	// Seed the LFSRRand() function
	LFSRSeedRand(GenerateRandomDWORD());

    MACInit();

#if defined(WF_CS_TRIS) && defined(STACK_USE_EZ_CONFIG) && !defined(__18CXX)
    WFEasyConfigInit();
#endif    

    ARPInit();

#if defined(STACK_USE_UDP)
    UDPInit();
#endif

#if defined(STACK_USE_TCP)
    TCPInit();
#endif

#if defined(STACK_USE_BERKELEY_API)
	BerkeleySocketInit();
#endif

#if defined(STACK_USE_HTTP2_SERVER)
    HTTPInit();
#endif

#if defined(STACK_USE_RSA)
	RSAInit();
#endif

#if defined(STACK_USE_SSL)
    SSLInit();
#endif

#if defined(STACK_USE_FTP_SERVER) && defined(STACK_USE_MPFS2)
    FTPInit();
#endif

#if defined(STACK_USE_SNMP_SERVER)
	SNMPInit();
#endif

#if defined(STACK_USE_DHCP_CLIENT)
	DHCPInit(0);
    if(!AppConfig.Flags.bIsDHCPEnabled)
    {
        DHCPDisable(0);
    }
#endif

#if defined(STACK_USE_AUTO_IP)
    AutoIPInit(0);
#endif

#if defined(STACK_USE_DYNAMICDNS_CLIENT)
	DDNSInit();
#endif

#if defined(STACK_USE_RANDOM)
	RandomInit();
#endif
}
/*****************************************************************************
  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;
}
Exemple #6
0
/*********************************************************************
 * Function:        void StackInit(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          Stack and its componets are initialized
 *
 * Side Effects:    None
 *
 * Note:            This function must be called before any of the
 *                  stack or its component routines are used.
 *
 ********************************************************************/
void StackInit(void)
{
   static BOOL once = FALSE;
    smStack                     = SM_STACK_IDLE;

#if defined(STACK_USE_IP_GLEANING) || defined(STACK_USE_DHCP_CLIENT)
    /*
     * If DHCP or IP Gleaning is enabled,
     * startup in Config Mode.
     */
    AppConfig.Flags.bInConfigMode = TRUE;

#endif

#if defined (WF_CS_TRIS) && defined (STACK_USE_DHCP_CLIENT)
   g_DhcpRenew = FALSE;
   g_DhcpRetryTimer = 0;
#endif

   if (!once) {
      // Seed the LFSRRand() function
      LFSRSeedRand(GenerateRandomDWORD());
      once = TRUE;
   }

    MACInit();

#if defined (WF_AGGRESSIVE_PS) && defined (WF_CS_TRIS)
   WFEnableAggressivePowerSave();
#endif

#if defined(WF_CS_TRIS) && defined(STACK_USE_EZ_CONFIG) && !defined(__18CXX)
    WFEasyConfigInit();
#endif    

    ARPInit();

#if defined(STACK_USE_UDP)
    UDPInit();
#endif

#if defined(STACK_USE_TCP)
    TCPInit();
#endif

#if defined(STACK_USE_BERKELEY_API)
   BerkeleySocketInit();
#endif

#if defined(STACK_USE_HTTP2_SERVER)
    HTTPInit();
#endif

#if defined(STACK_USE_RSA)
   RSAInit();
#endif

#if defined(STACK_USE_SSL)
    SSLInit();
#endif

#if defined(STACK_USE_FTP_SERVER) && defined(STACK_USE_MPFS2)
    FTPInit();
#endif

#if defined(STACK_USE_SNMP_SERVER)
   SNMPInit();
#endif

#if defined(STACK_USE_DHCP_CLIENT)
   DHCPInit(0);
    if(!AppConfig.Flags.bIsDHCPEnabled)
    {
        DHCPDisable(0);
    }
#endif

#if defined(STACK_USE_AUTO_IP)
    AutoIPInit(0);
#endif

#if defined(STACK_USE_DYNAMICDNS_CLIENT)
   DDNSInit();
#endif

#if defined(STACK_USE_RANDOM)
   RandomInit();
#endif

#if defined(STACK_USE_CCS_SMTP)
   SMTPInit();
#endif

#if defined(STACK_USE_CCS_SNTP_CLIENT)
   NTPInit();
#endif

#if defined(STACK_USE_CCS_GRATUITOUS_ARP)
   GratArpInit();
#endif

#if defined(STACK_USE_CCS_HTTP1_SERVER) || defined(STACK_USE_CCS_HTTP2_SERVER)
   HTTPInit();
#endif

   #if defined(STACK_USE_CCS_TFTP_SERVER)
   TFTPSInit();
   #endif
}
/*********************************************************************
 * Function:        void StackInit(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          Stack and its componets are initialized
 *
 * Side Effects:    None
 *
 * Note:            This function must be called before any of the
 *                  stack or its component routines are used.
 *
 ********************************************************************/
void StackInit(void)
{
    static bool once = false;
    smStack = SM_STACK_IDLE;

#if defined(STACK_USE_IP_GLEANING) || defined(STACK_USE_DHCP_CLIENT)
    /*
     * If DHCP or IP Gleaning is enabled,
     * startup in Config Mode.
     */
    AppConfig.Flags.bInConfigMode = true;
#endif

#if defined (WF_CS_TRIS) && defined (STACK_USE_DHCP_CLIENT)
    g_DhcpRenew = false;
    g_DhcpRetryTimer = 0;
#endif

    if (!once) {
        // Seed the LFSRRand() function
        LFSRSeedRand(GenerateRandomDWORD());
        once = true;
    }

    MACInit();

#if defined(WF_CS_TRIS) && defined(STACK_USE_EZ_CONFIG) && !defined(__XC8)
    WFEasyConfigInit();
#endif

    ARPInit();

#if defined(STACK_USE_ANNOUNCE)
    AnnounceInit();
#endif

#if defined(STACK_USE_UDP)
    UDPInit();
#endif

#if defined(STACK_USE_TCP)
    TCPInit();
#endif

#if defined(STACK_USE_BERKELEY_API)
    BerkeleySocketInit();
#endif

#if defined(STACK_USE_HTTP2_SERVER)
    HTTPInit();
#endif

#if defined(STACK_USE_RSA)
    RSAInit();
#endif

#if defined(STACK_USE_SSL)
    SSLInit();
#endif

#if defined(STACK_USE_FTP_SERVER) && defined(STACK_USE_MPFS2)
    FTPInit();
#endif

#if defined(STACK_USE_DHCP_CLIENT)
    DHCPInit(0);

    if(!AppConfig.Flags.bIsDHCPEnabled)
    {
        DHCPDisable(0);
    }
#endif

#if defined(STACK_USE_AUTO_IP)
    AutoIPInit(0);
#endif

#if defined(STACK_USE_DYNAMICDNS_CLIENT)
    DDNSInit();
#endif

#if defined(STACK_USE_RANDOM)
    RandomInit();
#endif

#if defined(STACK_USE_NBNS)
    NBNSInit();
#endif
}