DNSTest.c

DNSTest.c example details

The main DNS resolution is performed by function resolve_name():

host_address = resolve_name ("www.dsignt.de", 6);

The returned IP-address may be used for informational purpose or for creating a socket:

tcp_socket = socket_open (inet_ntoa (host_address, buffer),
                          ANY_PORT,
                          5031,
                          DATATYPE_CHAR,
                          TCP_INIT_FUNC);

Note

The DNS-lookup is already included with socket_open() function. For the same result as described above you can simply call:

tcp_socket = socket_open ("www.dsignt.de",
                          ANY_PORT,
                          5031,
                          DATATYPE_CHAR,
                          TCP_INIT_FUNC);

See also

DNS Domain Name System

/***************************************************************************//**

 @file       DNStest.c
 @brief      Performs a DNS-lookup to get the IP-address from www.dsignt.de.

 @verbatim
                           _         _             _
                        __| |    ___(_) ____ _ __ | |_
                       / _` |   / __| |/ _` | '_ \| __|
                      | (_| | _ \__ \ | (_| | | | | |_
                       \__,_|(_) ___/_|\__, |_| |_|\__|
                      Signalprocessing |___/ Technology
 @endverbatim

 @author     D.SignT GmbH & Co. KG, Claus Hermbusche
 @date       2019-06-04
 @anchor     DNSTESTEX

 @details
  The main DNS resolution is performed by function resolve_name():

      host_address = resolve_name ("www.dsignt.de", 6);

  The returned IP-address may be used for informational purpose or for creating
  a socket:

      tcp_socket = socket_open (inet_ntoa (host_address, buffer),
                                ANY_PORT,
                                5031,
                                DATATYPE_CHAR,
                                TCP_INIT_FUNC);

 @note       The DNS-lookup is already included with socket_open() function. For
  the same result as described above you can simply call:

      tcp_socket = socket_open ("www.dsignt.de",
                                ANY_PORT,
                                5031,
                                DATATYPE_CHAR,
                                TCP_INIT_FUNC);

 @cond       Software License Agreement
  Copyright (C) 2001-2019 D.SignT GmbH & Co. KG - http://www.dsignt.de

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:

    Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

    Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the
    distribution.

    Neither the name of D.SignT GmbH & Co. KG nor the names of its
    contributors may be used to endorse or promote products derived
    from this software without specific prior written permission.

  Disclaimer
  THIS SOFTWARE IS PROVIDED BY D.SIGNT GMBH & CO. KG "AS IS" AND ANY
  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL D.SIGNT GMBH & CO. KG BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 @endcond
*******************************************************************************/
/*******************************************************************************
  include stdtypes.h to avoid data type mismatch
*******************************************************************************/
#include <BoardSupport/inc/stdtypes.h>

/*******************************************************************************
  include Runtime Source
*******************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <inttypes.h>
#include <time.h>
#include <string.h>


/*******************************************************************************
  network support functions
*******************************************************************************/
#include <Libs/NETlib/net.h>                 /* D.Module network support      */

/*******************************************************************************
  board specific functions
*******************************************************************************/
#include <BoardSupport/inc/BoardSpecific.h>  /* board support functions       */

/*******************************************************************************
  common support functions
*******************************************************************************/
#include <Common/Common.h>                   /* on exit function              */
#include <Common/uartio.h>                   /* UART support                  */
#include <Common/timer.h>                    /* timer setting                 */
#include <Common/CPrintf.h>                  /* CPrintf defines               */

/*******************************************************************************
  network configuration
*******************************************************************************/
#include <BoardSupport/config/netconfig.c>   /* network configuration         */


#ifdef __cplusplus
extern "C" {
#endif /* !__cplusplus */

/*******************************************************************************
  local prototypes
*******************************************************************************/
#pragma CODE_SECTION(resolve_name , ".commontext")
uint32_t resolve_name ( char *hostname, int max_retry );

#ifdef __cplusplus
} // extern "C"
#endif


/*******************************************************************************
*                                                                              *
*    DEFINES                                                                   *
*                                                                              *
*******************************************************************************/
/*******************************************************************************
  MAX_PING_DATA is used to specify the maximum data to be pinged. For normal
  operation a value 64 to 100 should be sufficient.
*******************************************************************************/
#define MAX_PING_DATA             100

/*******************************************************************************
  host name to be resolved
*******************************************************************************/
#define HOST_NAME        "www.dsignt.de"


/*******************************************************************************
*                                                                              *
*    GLOBALS                                                                   *
*                                                                              *
*******************************************************************************/
/*******************************************************************************
 program name
*******************************************************************************/
char *program_name = "DNS";


/*******************************************************************************
*                                                                              *
*    FUNCTIONS                                                                 *
*                                                                              *
*******************************************************************************/

/*******************************************************************************

 @brief      perform DNS lookup

 @param      hostname  - name to resolve
 @param      max_retry - number of retries (useful on dial-up connection)
 @return     resolved IP-address on success or zero (0) on error
 @sa         gethostbyname() - net.lib

*******************************************************************************/
uint32_t resolve_name ( char *hostname, int max_retry )
{
    /***************************************************************************
     locals
    ***************************************************************************/
    uint32_t ret = UINT32_C(0);
    int32_t timeout;
    int i;

    for ( i = 0; i < max_retry ; i++ )
    {
        CPrintChar ('.', 1);

        /***********************************************************************
          configure timeout value to break the action if name resolution is not
          possible
        ***********************************************************************/
        timeout = 500000;

        /***********************************************************************
          resolve address:
        ***********************************************************************/
        ret = gethostbyname (hostname, &timeout);

        if ( ret ) // on success stop loop
        {
            break;
        }
    }

    return (ret);
}

/*******************************************************************************

 @brief      Main application
 @param      -
 @return     never

*******************************************************************************/
#pragma CODE_SECTION(main , ".commontext");
int main ( void )
{
    /***************************************************************************
     locals
    ***************************************************************************/
    int main_loop = 1;                /* main loop switch, set to 0 to exit   */
    timeval stamp1, stamp2, delta;    /* used to determine startup time       */
    uint32_t host_address;
    char buffer[20];

    /***************************************************************************
      initialize application (e.g. timer clocks, PLL settings, EMIF etc.)
       (ref. \Common\Common.c)
    ***************************************************************************/
    AppInit (GET_CLOCK);

    /***************************************************************************
      select output device for CPrintf  (ref. \Common\cprintf.c)
      possible settings:
        CPRINTF_UART_OUTPUT                       -> output to UART
        CPRINTF_CCS_OUTPUT                        -> output to CCS
        CPRINTF_UART_OUTPUT | CPRINTF_CCS_OUTPUT  -> output to UART and CCS
    ***************************************************************************/
    CPrintf_select_output (CPRINTF_DEFAULT_OUTPUT);  /* default outputs       */

    /***************************************************************************
     print a start up message
    ***************************************************************************/
    START_UP_MESSAGE (BLANK_REV NETLIB_REV);

    /**************************************************************************/
    // CPrintfProgress (" Heap check ");
    // at least 0x2000 bytes required for this app
    /**************************************************************************/
    ASSERT_HEAP (initial_heap_size, 0x2000);
    // CPrintfProgressSuccess();

    /**************************************************************************/
     CPrintfProgress (" Setup system time ");
     // 1 milli seconds resolution
    /**************************************************************************/
    SetupSystemTime ( SYSTEM_TIMER_INT, SYSTEM_TIMER, RES_MSECONDS);
    CPrintfProgressSuccess();
    CPrintf ("   *** timer %d mapped to CPU int %d ***\r\n",
             SystemTimerDev, SYSTEM_TIMER_INT);

    /**************************************************************************/
     CPrintfProgress (" Enable interrupts ");
    /**************************************************************************/
    BoardEnableInterrupts();
    CPrintfProgressSuccess();

    /**************************************************************************/
     CPrintfProgress (" Start system timer ");
    /**************************************************************************/
    StartSystemTimer ();
    CPrintfProgressSuccess();
    CPrintf ("   *** timer %d running at %"PRId32" Hz ***\r\n", SystemTimerDev, RES_SECONDS/GetSystemTimerRes());

    /***************************************************************************
      measure network initialization time
    ***************************************************************************/
    stamp1 = GetTimeStamp();

    /**************************************************************************/
     CPrintfProgress (" Initialize network ");
    /**************************************************************************/
    InitializeNetwork ( MAX_PING_DATA); // MAX_PING_DATA bytes for ping
    CPrintfProgressSuccess();

    stamp2 = GetTimeStamp();

    tv_interval (&delta, &stamp1, &stamp2);
    CPuts (" network startup time [sec]: ");
    CPrintf (VT100_RED
             "%"PRId32".%03"PRId32"\r\n"
             VT100_DEFAULT,
              delta.tv_sec,
              delta.tv_usec/1000);


    /***************************************************************************
     wait for link and IP address
    ***************************************************************************/
    while ((_link == 0) || (get_ip_address (0) == UINT32_C(0)))
    {
        /***********************************************************************
         perform progress bar animation each 200 milli second
        ***********************************************************************/
        CPrintProgressBarText  ('.', 200000, 16,  " waiting for link");

        net_isq ();

        /***********************************************************************
         monitor link status
        ***********************************************************************/
        monitor_link_status (CPrintf);
    }

    CPrintf ("success\r\n try to resolve %s...\r\n", HOST_NAME);

    /***************************************************************************
      resolve DSignT's IP
    ***************************************************************************/
    host_address = resolve_name (HOST_NAME, 6);

    if ( host_address == 0L )
    {
        CPuts (" address can not be resolved\r\n");
    }
    else
    {
        CPrintf (" resolved IP-address for %s: %s\r\n",
                HOST_NAME,
                inet_ntoa (host_address, buffer));
    }

    /***************************************************************************
      main program loop: set main_loop to 0 to exit loop
    ***************************************************************************/
    while ( main_loop )
    {
        net_isq ();

        /***********************************************************************
         show that the program is running, perform symbol animation
        ***********************************************************************/
        CPrintAnimatedSymbol ( sym_animate, 200000, ANIMATE_SYMBOLS_COUNT);
    }

    /***************************************************************************
      exit program, shut down peripherals
    ***************************************************************************/
    return (0);
}