/*********************************************************************
*
* DNS Client Module for Microchip TCP/IP Stack
* -Provides DNS resolution (client)
*
*********************************************************************
* FileName: DNS.c
* Dependencies: UDP, ARP, Tick
* Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
* Complier: Microchip C18 v3.02 or higher
* Microchip C30 v2.01 or higher
* Company: Microchip Technology, Inc.
*
* Software License Agreement
*
* This software is owned by Microchip Technology Inc. ("Microchip")
* and is supplied to you for use exclusively as described in the
* associated software agreement. This software is protected by
* software and other intellectual property laws. Any use in
* violation of the software license may subject the user to criminal
* sanctions as well as civil liability. Copyright 2006 Microchip
* Technology Inc. All rights reserved.
*
* This software is provided "AS IS." MICROCHIP DISCLAIMS ALL
* WARRANTIES, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, NOT LIMITED
* TO MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
* INFRINGEMENT. Microchip shall in no event be liable for special,
* incidental, or consequential damages.
*
*
* Author Date Comment
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Howard Schlunder 7/31/06 Original
********************************************************************/
#define THIS_IS_DNS
#include "..\Include\Compiler.h"
#include "..\Include\UDP.h"
#include "..\Include\Tick.h"
#include "..\Include\ARP.h"
#include "..\Include\ARPTsk.h"
#include "..\Include\DNS.h"
#include "..\Include\Helpers.h"
#if defined(STACK_USE_DNS)
#define DNS_PORT 53
#define DNS_TIMEOUT (TICK_1S*2)
static BYTE *DNSHostName;
static enum
{
DNS_HOME = 0,
DNS_RESOLVE_ARP,
DNS_OPEN_SOCKET,
DNS_QUERY,
DNS_GET_RESULT,
DNS_DONE
} smDNS = DNS_DONE;
typedef struct _DNS_HEADER
{
WORD_VAL TransactionID;
WORD_VAL Flags;
WORD_VAL Questions;
WORD_VAL Answers;
WORD_VAL AuthoritativeRecords;
WORD_VAL AdditionalRecords;
} DNS_HEADER;
typedef struct _DNS_ANSWER_HEADER
{
WORD_VAL ResponseName;
WORD_VAL ResponseType;
WORD_VAL ResponseClass;
DWORD_VAL ResponseTTL;
WORD_VAL ResponseLen;
} DNS_ANSWER_HEADER;
static void DNSPutString(BYTE *String);
static void DNSGetString(BYTE *String);
/*********************************************************************
* Function: void DNSResolve(BYTE *Hostname)
*
* PreCondition: Stack is initialized()
*
* Input: *Hostname: Null terminated string specifying the
* host address to resolve to an IP
* address.
*
* Output: None
*
* Side Effects: None
*
* Overview: Call DNSIsResolved() until the host is resolved.
*
* Note: A UDP socket must be available before this
* function is called. It is freed at the end of
* the resolution. MAX_UDP_SOCKETS may need to be
* increased if other modules use UDP sockets.
*
* You must not modify *Hostname until DNSIsResolved()
* returns TRUE.
********************************************************************/
void DNSResolve(BYTE *Hostname)
{
DNSHostName = Hostname;
smDNS = DNS_HOME;
}
/*********************************************************************
* Function: BOOL DNSIsResolved(IP_ADDR *HostIP)
*
* PreCondition: DNSResolve() was called.
*
* Input: HostIP: Pointer to IP_ADDR structure to store the
* returned host IP address when DNS
* resolution is complete.
*
* Output: *HostIP, 4 byte IP address
*
* Side Effects: None
*
* Overview: Call DNSIsResolved() until the host is resolved.
*
* Note: You cannot start two DNS resolution proceedures
* concurrently.
*
* You must not modify *Hostname until DNSIsResolved()
* returns TRUE.
********************************************************************/
BOOL DNSIsResolved(IP_ADDR *HostIP)
{
static UDP_SOCKET MySocket;
static NODE_INFO Remote;
static TICK StartTime;
BYTE i;
WORD_VAL w;
DNS_HEADER DNSHeader;
DNS_ANSWER_HEADER DNSAnswerHeader;
switch(smDNS)
{
case DNS_HOME:
ARPResolve(&AppConfig.PrimaryDNSServer);
StartTime = tickGet();
smDNS++;
break;
case DNS_RESOLVE_ARP:
if(!ARPIsResolved(&AppConfig.PrimaryDNSServer, &Remote.MACAddr))
{
if(tickGet() - StartTime > DNS_TIMEOUT)
{
smDNS--;
}
break;
}
Remote.IPAddr.Val = AppConfig.PrimaryDNSServer.Val;
smDNS++;
// No need to break, we can immediately start resolution
case DNS_OPEN_SOCKET:
MySocket = UDPOpen(0, &Remote, DNS_PORT);
if(MySocket == INVALID_UDP_SOCKET)
break;
smDNS++;
// No need to break, we can immediately start resolution
case DNS_QUERY:
if(!UDPIsPutReady(MySocket))
break;
// Put DNS query here
UDPPut(0x12); // User chosen ID
UDPPut(0x34);
UDPPut(0x01); // Standard query with recursion
UDPPut(0x00);
UDPPut(0x00); // 0x0001 questions
UDPPut(0x01);
UDPPut(0x00); // 0x0000 answers
UDPPut(0x00);
UDPPut(0x00); // 0x0000 name server resource records
UDPPut(0x00);
UDPPut(0x00); // 0x0000 additional records
UDPPut(0x00);
// Put hostname string to resolve
DNSPutString(DNSHostName);
UDPPut(0x00); // Type: A (host address)
UDPPut(0x01);
UDPPut(0x00); // Class: IN (Internet)
UDPPut(0x01);
UDPFlush();
StartTime = tickGet();
smDNS++;
break;
case DNS_GET_RESULT:
if(!UDPIsGetReady(MySocket))
{
if(tickGet() - StartTime > DNS_TIMEOUT)
{
smDNS--;
}
break;
}
// Retrieve the DNS header and de-big-endian it
UDPGet(&DNSHeader.TransactionID.v[1]);
UDPGet(&DNSHeader.TransactionID.v[0]);
UDPGet(&DNSHeader.Flags.v[1]);
UDPGet(&DNSHeader.Flags.v[0]);
UDPGet(&DNSHeader.Questions.v[1]);
UDPGet(&DNSHeader.Questions.v[0]);
UDPGet(&DNSHeader.Answers.v[1]);
UDPGet(&DNSHeader.Answers.v[0]);
UDPGet(&DNSHeader.AuthoritativeRecords.v[1]);
UDPGet(&DNSHeader.AuthoritativeRecords.v[0]);
UDPGet(&DNSHeader.AdditionalRecords.v[1]);
UDPGet(&DNSHeader.AdditionalRecords.v[0]);
// Remove all questions
while(DNSHeader.Questions.Val--)
{
DNSGetString(NULL);
UDPGet(&w.v[1]); // Question type
UDPGet(&w.v[0]);
UDPGet(&w.v[1]); // Question class
UDPGet(&w.v[0]);
}
// Scan through answers
while(DNSHeader.Answers.Val--)
{
UDPGet(&DNSAnswerHeader.ResponseName.v[1]); // Response name
UDPGet(&DNSAnswerHeader.ResponseName.v[0]);
UDPGet(&DNSAnswerHeader.ResponseType.v[1]); // Response type
UDPGet(&DNSAnswerHeader.ResponseType.v[0]);
UDPGet(&DNSAnswerHeader.ResponseClass.v[1]); // Response class
UDPGet(&DNSAnswerHeader.ResponseClass.v[0]);
UDPGet(&DNSAnswerHeader.ResponseTTL.v[3]); // Time to live
UDPGet(&DNSAnswerHeader.ResponseTTL.v[2]);
UDPGet(&DNSAnswerHeader.ResponseTTL.v[1]);
UDPGet(&DNSAnswerHeader.ResponseTTL.v[0]);
UDPGet(&DNSAnswerHeader.ResponseLen.v[1]); // Response length
UDPGet(&DNSAnswerHeader.ResponseLen.v[0]);
// Make sure that this is a 4 byte IP address, response type A, class 1
// Check if this is Type A
if( DNSAnswerHeader.ResponseType.Val == 0x0001 &&
DNSAnswerHeader.ResponseClass.Val == 0x0001 && // Internet class
DNSAnswerHeader.ResponseLen.Val == 0x0004)
{
UDPGet(&HostIP->v[0]);
UDPGet(&HostIP->v[1]);
UDPGet(&HostIP->v[2]);
UDPGet(&HostIP->v[3]);
break;
}
else
{
while(DNSAnswerHeader.ResponseLen.Val--)
{
UDPGet(&i);
}
}
}
UDPDiscard();
UDPClose(MySocket);
MySocket = INVALID_UDP_SOCKET;
smDNS++;
// No need to break, we are done and need to return TRUE
case DNS_DONE:
return TRUE;
}
return FALSE;
}
static void DNSPutString(BYTE *String)
{
BYTE *RightPtr;
BYTE i;
BYTE Len;
RightPtr = String;
while(1)
{
do
{
i = *RightPtr++;
} while((i != 0x00) && (i != '.') && (i != '/'));
// Put the length parameter
Len = (BYTE)(RightPtr-String-1);
UDPPut(Len);
while(Len--)
{
UDPPut(*String++);
}
if(i == 0x00 || i == '/')
break;
// Skip over the '.' in the input string
String++;
}
// Put the string terminator character
UDPPut(0x00);
}
static void DNSGetString(BYTE *String)
{
BYTE i;
BYTE j;
if(String == NULL)
{
UDPGet(&i);
while(i)
{
while(i--)
{
UDPGet(&j);
}
UDPGet(&i);
}
}
else
{
UDPGet(&i);
while(i)
{
while(i--)
{
UDPGet(String);
String++;
}
UDPGet(&i);
}
}
}
#endif //#if defined(STACK_USE_DNS)