ETHNET DHCP

#include "dhcp_thread.h"


/* Define the function to call for running a DHCP session. */
UINT run_dhcp_client_session(NX_DHCP *client_ptr, NX_IP *ip_ptr);


/* If define, debug output sent to Renesas Virtual Console */
#define SEMI_HOSTING

/* Define the wait limit for getting assigned an IP address.
 * NX_IP_PERIODIC_RATE is defined internally in NetX for converting
 * seconds to timer ticks. This timeout is defined for 2 seconds.
 */
#define WAIT_TO_BE_BOUND            (10*NX_IP_PERIODIC_RATE)

/* Define error status returns */
#define DHCP_RUN_ERRORS     0x1001
#define DHCP_START_ERROR    0x1002



/* If semi hosting is defined, define the debug output
 * method using printf.
 */
#ifdef SEMI_HOSTING
#include "stdio.h"
#ifdef __GNUC__
extern void initialise_monitor_handles(void);
#endif
#endif


/* Define some global variables. */
static UINT error_counter = 0;
static UINT is_bound = NX_FALSE;

/* Declare the DHCP Client state change callback. */
static  VOID   my_notify_callback(NX_DHCP *dhcp_ptr, UCHAR new_state);

char * xp_str_ip(char * x, uint32_t ip)
{
    sprintf(x, "%u.%u.%u.%u",
            (uint8_t)(ip>>24 & 0xFF),
            (uint8_t)(ip>>16 & 0xFF),
            (uint8_t)(ip>>8  & 0xFF),
            (uint8_t)(ip>>0  & 0xFF));

    return x;
}

/**
 * This function runs a DHCP Client session.
 * client_ptr; pointer to an NX_DHCP instance, an already created DHCP Client instance
 * ip_ptr; pointer to an NX_IP instance, an already created IP instance
 * If successful return NX_SUCCESS (0x0); else return DHCP_RUN_ERRORS error status.
 */
UINT run_dhcp_client_session(NX_DHCP *client_ptr, NX_IP *ip_ptr)
{

UINT        status;
NX_PACKET   *my_packet;
ULONG       server_address;
ULONG       client_address;
ULONG       network_mask;
UCHAR       buffer[4];
UINT        buffer_size = 4;
ULONG       *dns_server_ptr;
UINT        wait = 0;
UINT        wait_limit;
char    ip_string[20] = {0};

      /* Initialize the debug output utility. */
#ifdef SEMI_HOSTING
#ifdef __GNUC__
    initialise_monitor_handles();
#endif
#endif

    /* Register a DHCP state change callback function. */
    status = nx_dhcp_state_change_notify(client_ptr, my_notify_callback);

    if (status)
        error_counter++;

    /* Now we‘re ready to start the DHCP Client.  */
    status =  nx_dhcp_start(client_ptr);

     /* Check the status. */
    if (status)
    {
        error_counter++;

#ifdef SEMI_HOSTING
        if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
        {
            /* Debugger is connected */
            printf("Aborting DHCP Client. Failed DHCP start 0x%x\n", status);
        }
#endif
        /* Internal DHCP error or NetX internal error. We cannot continue this demo test. */
        nx_dhcp_delete(client_ptr);

        return DHCP_START_ERROR;
    }

#ifdef SEMI_HOSTING
        if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
        {
            /* Debugger is connected */
            printf("DHCP Client is running\n");
        }
#endif
    /* Wait for the flag that the Client is Bound is set. */
    wait = 0;
    wait_limit = WAIT_TO_BE_BOUND;

    while(wait < wait_limit)
    {

        /* If the is_bound flag is set, we have a valid IP address */
        if (is_bound == NX_TRUE)
            break;

        /* Not bound yet. Let other application threads run. */
        tx_thread_sleep(100);

        /* Update how long we‘ve waited */
        wait += 100;
    }

    /* Check if Client is bound to an IP address. */
    if (is_bound)
    {
#ifdef SEMI_HOSTING
        if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
        {
            /* Debugger is connected */
            printf("DHCP Client is assigned an IP address lease.\n");
        }
#endif

        /* It is. Get the client IP address from this NetX service. */
        status = nx_ip_address_get(ip_ptr, &client_address, &network_mask);

        /* Check for errors. */
        if (status)
            error_counter++;
        else
        {
#ifdef SEMI_HOSTING
            if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
            {
                /* Debugger is connected */
                printf("DHCP Client address is 0x%x. \n",(unsigned int)client_address);
                xp_str_ip(ip_string, client_address);
                printf("DHCP Client address is:%s\n",ip_string);
            }
#endif
        }

        /* Get the DHCP Server IP address.  */
        status = nx_dhcp_server_address_get(client_ptr, &server_address);

        /* Check for errors. */
        if (status)
        {
            error_counter++;
        }
        else
        {
            /* Check that the device is able to send and receive packets with this IP address. */
            status =  nx_icmp_ping(ip_ptr, server_address, "Hello World", sizeof("Hello World"), &my_packet, 3* NX_IP_PERIODIC_RATE);

#ifdef SEMI_HOSTING
            if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
            {
                /* Debugger is connected */
                printf("DHCP Server IP address is 0%x.\n", (unsigned int)server_address);
                xp_str_ip(ip_string, server_address);
                printf("DHCP Server address is:%s\n",ip_string);
            }
#endif

            /* Check status. */
            if (status)
                /* No valid ICMP packet received (no packet to release). Update the error counter. */
                error_counter++;
            else
            {
#ifdef SEMI_HOSTING
                if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
                {
                    /* Debugger is connected */
                    printf("Successfully pinged Server.\n");
                }
#endif
                /* Release the echo response packet when we are done with it. */
                nx_packet_release(my_packet);
            }
        }
    }

     /* Stop the DHCP Client. The application can still send and receive network packets. */
    status = nx_dhcp_stop(client_ptr);

    if (status)
        error_counter++;

    /* Prepare the DHCP Client to restart. We can still send and receive
     * packets except broadcast packets, but with a source IP address
     * of zero, is not very useful except for DHCP. */
    status = nx_dhcp_reinitialize(client_ptr);

    if (status)
         error_counter++;

#ifdef SEMI_HOSTING
    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
    {
        /* Debugger is connected */
        printf("DHCP Client is reinitializing...\n");
    }
#endif

    /* Some time later.... */
    tx_thread_sleep(100);

    /* Clear our previous DHCP session flag. */
    is_bound = NX_FALSE;

    /* Restart the DHCP Client thread task. */
    status = nx_dhcp_start(client_ptr);

#ifdef SEMI_HOSTING
    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
    {
        /* Debugger is connected */
        printf("DHCP Client is restarted...\n");
    }
#endif

    /* Check status.  */
    if (status)
    {
        /* Update the error count. */
        error_counter++;


#ifdef SEMI_HOSTING
        if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
        {
            /* Debugger is connected */
            printf("Aborting DHCP Client. Failed 2nd DHCP start 0x%x\n", status);
        }
#endif
        /* Internal DHCP error or NetX internal error. We cannot continue this demo test. */
        nx_dhcp_delete(client_ptr);
    }
    else
    {
        /* This time we‘ll poll the IP instance directly for a valid IP address.  */
        wait = 0;
        do
        {
            UINT actual_status;

            /* Check for address resolution.  */
            status = nx_ip_status_check(ip_ptr, NX_IP_ADDRESS_RESOLVED, (ULONG *) &actual_status, NX_IP_PERIODIC_RATE);

            /* Check status.  */
            if (status)
            {
                /* wait a bit. */
                tx_thread_sleep(NX_IP_PERIODIC_RATE);

                wait += NX_IP_PERIODIC_RATE;
                if (wait >= wait_limit)
                {
                    break;
                }
            }

        } while (status != NX_SUCCESS);

        /* Check if we have a valid address. */
        if (status == NX_SUCCESS)
        {

#ifdef SEMI_HOSTING
            if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
            {
                /* Debugger is connected */
                printf("DHCP Client is assigned IP address lease for a second time.\n");
            }
#endif
            /* We do. This time, query the DHCP Client for the DNS Server address.  */
            status = nx_dhcp_user_option_retrieve(client_ptr, NX_DHCP_OPTION_DNS_SVR, buffer, &buffer_size);

            /* Check status.  */
            if (status)
                error_counter++;
            else
            {
                dns_server_ptr = (ULONG *)(buffer);

                /* Send a ping request to the DNS server. */
                status =  nx_icmp_ping(ip_ptr, *dns_server_ptr, "Hello DNS Server", sizeof("Hello DNS Server"), &my_packet, 3* NX_IP_PERIODIC_RATE);

                /* No valid ICMP packet received (no packet to release). Update the error counter. */
                if (status)
                    error_counter++;
                else
                {
#ifdef SEMI_HOSTING
                    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
                    {
                        /* Debugger is connected */
                        printf("Successfully pinged Server.\n");
                    }
#endif
                    /* Release the echo response packet when we are done with it. */
                    nx_packet_release(my_packet);
                }
            }


            /* We‘re done with the DHCP Client. */

            /* Release the IP address back to the Server. This application should not
               send or receive packets with this IP address now. */
            status = nx_dhcp_release(client_ptr);
            if (status)
                error_counter++;
            else
            {
#ifdef SEMI_HOSTING
                if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
                {
                    /* Debugger is connected */
                    printf("Released IP address back to Server.\n");
                }
#endif
            }
        }
#ifdef SEMI_HOSTING
        if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
        {
            /* Debugger is connected */
            printf("Stopping the DHCP Client.\n");
        }
#endif

         /* Stop the DHCP Client and unbind the DHCP UDP socket.*/
        status = nx_dhcp_stop(client_ptr);

        if (status)
            error_counter++;

    }

    /* All done. Delete the Client and release resources to NetX and ThreadX. */
    status = nx_dhcp_delete(client_ptr);

    if (status)
        error_counter++;

#ifdef SEMI_HOSTING
    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk)
    {
        /* Debugger is connected */
        printf("DHCP Client demo has completed with %d errors.\n", error_counter);
    }
#endif

    /* Return a status value based on any errors encountered. */
    if (error_counter == 0)
    {
        return NX_SUCCESS;
    }
    else
    {

        return DHCP_RUN_ERRORS;
    }
}

/**
 * This function defines a user callback for DHCP Client to notify
 * when there is a DHCP state change.
 * NX_DHCP *client_ptr; previously created DHCP Client instance
 * UCHAR state; 2 byte numeric representation of DHCP state
 * void
 *
 * In this callback, we only check if the DHCP
 * Client has changed to the bound state (has a valid IP
 * address) and we set a flag for the application to check.
 */
VOID my_notify_callback(NX_DHCP *dhcp_ptr, UCHAR state)
{

    UINT new_state = (UINT)state;

    NX_PARAMETER_NOT_USED(dhcp_ptr);

    /* Check if we have transitioned to the bound state
       (have a valid IP address). */
    if (new_state == NX_DHCP_STATE_BOUND)
    {
        /* We have. Set the flag for the application. */
        is_bound = NX_TRUE;
    }
}





/* Define the application thread.  */
void dhcp_thread_entry(void)
{

    UINT error_counter = 0;
    UINT status;

    /* Wait for the IP stack and network hardware
     * to get initialized.
     */
    tx_thread_sleep(3 *NX_IP_PERIODIC_RATE);

    /* Start and run a brief DHCP Client session. */
    status = run_dhcp_client_session(&g_dhcp_client0, &g_ip0);


    /* Check for successful result. */
    if (status)
        error_counter++;
}

DHCP Client is running
DHCP Client is assigned an IP address lease.
DHCP Client address is 0xc0a81f7d. 
DHCP Client address is:192.168.31.125
DHCP Server IP address is 0c0a81f01.
DHCP Server address is:192.168.31.1
Successfully pinged Server.
DHCP Client is reinitializing...
DHCP Client is restarted...
DHCP Client is assigned IP address lease for a second time.
Successfully pinged Server.
Released IP address back to Server.
Stopping the DHCP Client.
DHCP Client demo has completed with 0 errors.