dns_resolver.c revision d65680efa46fa49e8bf14e67b29b782510ff934c
/**************************************************************************
*
* dns_resolver.c: Etherboot support for resolution of host/domain
* names in filename parameters
* Written 2004 by Anselm M. Hoffmeister
* <stockholm@users.sourceforge.net>
*
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* This code is using nuts and bolts from throughout etherboot.
* It is a fresh implementation according to the DNS RFC, #1035
*
* $Revision$
* $Author$
* $Date$
*
* REVISION HISTORY:
* ================
* 2004-05-10 File created
* 2004-05-19 First release to CVS
* 2004-05-22 CNAME support first stage finished
* 2004-05-24 First "stable" release to CVS
* 2004-08-28 Improve readability, set recursion flag
***************************************************************************/
/*
* Sun GPL Disclaimer: For the avoidance of doubt, except that if any license choice
* other than GPL or LGPL is available it will apply instead, Sun elects to use only
* the General Public License version 2 (GPLv2) at this time for any software where
* a choice of GPL license versions is made available with the language indicating
* that GPLv2 or any later version may be used, or where a choice of which version
* of the GPL is applied is otherwise unspecified.
*/
#ifdef DNS_RESOLVER
#include "etherboot.h"
#include "nic.h"
#include "dns_resolver.h"
#define MAX_DNS_RETRIES 3
#define MAX_CNAME_RECURSION 0x30
/*
* dns_resolver
* Function: Main function for name resolution - will be called by other
* parts of etherboot
* Param: string filename (not containing proto prefix like "tftp://")
* Return: string filename, with hostname replaced by IP in dotted quad
* or NULL for resolver error
* In case no substitution is necessary, return will be = param
* The returned string, if not == input, will be temporary and
* probably be overwritten during the next call to dns_resolver
* The returned string may (or may not) only contain an IP
* address, or an IP followed by a ":" or "/", or be NULL(=error)
*/
char * dns_resolver ( char * filename ) {
int i = 0, j, k;
static char ipaddr[16] = { 0 };
// Search for "end of hostname" (which might be either ":" or "/")
// If no hostname delimiter was found, assume no name present
}
// Check if the filename is an IP, in which case, leave unchanged
k = j - i - 1;
while ( ( '.' == filename[i+k] ) ||
--k;
if ( k < 0 ) return filename; // Only had nums and dots->IP
}
// Now that we know it's a full hostname, attempt to resolve
return NULL; // Error in resolving - Fatal.
}
// Return the dotted-quad IP which resulted
return ipaddr;
}
/*
* await_dns
* Shall be called on any incoming packet during the resolution process
* (as is the case with all the other await_ functions in etherboot)
* Param: as any await functions
* Return: see dns_resolver.h for constant return values + descriptions
*/
int i, j, k;
// p is set to the beginning of the payload
unsigned char *q;
unsigned int querytype = QUERYTYPE_A;
if ( 0 == udp ) // Parser couldn't find UDP header
return RET_PACK_GARBAG; // Not a UDP packet
// Neither source nor destination port is "53"
return RET_PACK_GARBAG; // UDP port wrong
if (( p[QINDEX_ID ] != 0) ||
// Checking if this packet has set (inside payload)
// the sequence identifier that we expect
return RET_PACK_GARBAG; // Not matching our request ID
// We only accept responses to the query(ies) we sent
return RET_PACK_GARBAG; // Is not response=opcode <0>
// Answer section has 0 entries, or "no such name" returned
if ( QUERYTYPE_A == querytype) {
// It was an A type query, so we should try if there's
// an alternative "CNAME" record available
return RET_RUN_CNAME_Q; // So try CNAME query next
} else if ( QUERYTYPE_CNAME == querytype) {
// There's no CNAME either, so give up
return RET_NOSUCHNAME;
} else {
// Anything else? No idea what. Should not happen.
return RET_NOSUCHNAME; // Bail out with error
}
}
// The response packet's flag section tells us:
return RET_NOSUCHNAME; // Another (unspecific) error occured
// Now we have an answer packet in response to our query. Next thing
// to do is to search the payload for the "answer section", as there is
// a question section first usually that needs to be skipped
// If question section was not repeated, that saves a lot of work :
q = p+ QINDEX_QUESTION; // No question section, just continue;
} else if ( i >= 2 ) { // More than one query section? Error!
return RET_NOSUCHNAME; // That's invalid for us anyway -
// We only place one query at a time
} else {
// We have to skip through the question section first to
// find the beginning of the answer section
q = p + QINDEX_QUESTION;
while ( 0 != q[0] )
q += q[0] + 1; // Skip through
q += 5; // Skip over end-\0 and query type section
}
// Now our pointer shows the beginning of the answer section
// So now move it past the (repeated) query string, we only
// want the answer
while ( 0 != q[0] ) {
if ( 0xc0 == ( q[0] & 0xc0 ) ) { // Pointer
++q;
break;
}
q += q[0] + 1;
}
++q;
// Now check wether it's an INET host address (resp. CNAME)?
// There seem to be nameservers out there (Bind 9, for example),
// that return CNAMEs when no As are there, e.g. in
// testname.test. IN CNAME othername.test.
// case, bind 9 would return the CNAME record on an A query.
// Accept this case as it saves a lot of work (an extra query)
if (( QUERYTYPE_CNAME == q[1] ) &&
( QUERYTYPE_A == querytype )) {
// A query, but CNAME response.
// Do simulate having done a CNAME query now and just assume
// the answer we are working on here is that of a CNAME query
// This works for single-depth CNAMEs fine.
// For deeper recursion, we won't parse the answer
// packet deeper but rely on a separate CNAME query
}
// Now check wether the answer packet is of the expected type
// (remember, we just tweaked CNAME answers to A queries already)
if ( (q[0] != 0) ||
return RET_DNSERROR; // Should not happen. DNS server bad?
}
if ( querytype == QUERYTYPE_A ) {
// So what we sent was an A query - expect an IPv4 address
// Check if datalength looks satisfactory
if ( ( 0 != q[0] ) || ( 4 != q[1] ) ) {
// Data length is not 4 bytes
return RET_DNSERROR;
}
// Go to the IP address and copy it to the response buffer
p = ptr + QINDEX_STORE_A;
for ( i = 0; i < 4; ++i ) {
p[i] = q[i+2];
}
return RET_GOT_ADDR; // OK! Address RETURNED! VERY FINE!
// The pointer "q" now stands on the "payload length" of the
// CNAME data [2 byte field]. We will have to check wether this
// name is referenced in a following response, which would save
// us further queries, or if it is standalone, which calls for
// making a separate query
// This statement above probably needs clarification. To help
// the reader understand what's going on, imagine the DNS
// answer to be 4-section: query(repeating what we sent to the
// DNS server), answer(like the CNAME record we wanted),
// additional (which might hold the A for the CNAME - esp.
// Bind9 seems to provide us with this info when we didn't
// query for it yet) and authoritative (the DNS server's info
// on who is responsible for that data). For compression's
// sake, instead of specifying the full hostname string all
// the time, one can instead specify something like "same as on
// payload offset 0x123" - if this happens here, we can check
// if that payload offset given here by coincidence is that of
// an additional "A" record which saves us sending a separate
// query.
// We will look if there's a/ two or more answer sections
// AND b/ the next is a reference to us.
i = q + 2 - p;
if ( p[7] > 1 ) { // More than one answer section
// Check the next if it's a ref
// For that, we have to locate the next. Do this with "q".
p = q + (q[0] * 0x100) + q[1] + 2;
if ( (p[0] == (0xc0 + ((i & 0xf00)/256))) &&
(p[1] == (i & 0xff) ) &&
(p[10]== 0) && // Data length expected
(p[11]== 4)) { // to be <4> (IP-addr)
// Behind that sections: TTL, data length(4)
for ( i = 0; i < 4; ++i ) {
((unsigned char*)ptr)[QINDEX_STORE_A+i] =
p[12+i];
}
return RET_GOT_ADDR;
}
}
// Reference not found, next query (A) needed (because CNAME
// queries usually return another hostname, not an IP address
// as we need it - that's the point in CNAME, anyway :-)
#ifdef DNSDEBUG
printf ( " ->[");
#endif
k = QINDEX_QUESTION;
i = (q-p) + 2;
// Compose the hostname that needs to be queried for
// This looks complicated (and is a little bit) because
// we might not be able to copy verbatim, but need to
// check wether the CNAME looks like
// "servername" "plus what offset 0x123 of the payload says"
// (this saves transfer bandwidth, which is why DNS allows
// this, but it makes programmers' lives more difficult)
while (p[i] != 0) {
if ( (((unsigned char *)p)[i] & 0xc0) != 0 ) {
i = ((p[i] & 0x3f) * 0x100) + p[i+1];
continue;
}
((unsigned char *)ptr)[k] = p[i];
for ( j = i + 1; j <= i + p[i]; ++j ) {
((unsigned char *)ptr)[k+j-i] = p[j];
#ifdef DNSDEBUG
printf ( "%c", p[j] );
#endif
}
k += ((unsigned char *)ptr)[k] + 1;
i += p[i] + 1;
#ifdef DNSDEBUG
#endif
}
((unsigned char *)ptr)[k] = 0;
#ifdef DNSDEBUG
printf ( "].." );
#endif
// So we need to run another query, this time try to
// get an "A" record for the hostname that the last CNAME
// query pointed to
return RET_RUN_NEXT_A;
}
// We only accept CNAME or A replies from the nameserver, every-
// thing else is of no use for us.
// Must be an invalid packet that the nameserver sent.
return RET_DNSERROR;
}
// Count the number of characters of this part of a hostname
int i;
for ( i = 1; i < maxnum; ++i ) {
if ( countfrom[i] == '.' ) return i;
}
return maxnum;
}
/*
* donameresolution
* Function: Compose the initial query packet, handle answers until
* a/ an IP address is retrieved
* b/ too many CNAME references occured (max. MAX_DNS_RETRIES)
* c/ No matching record for A or CNAME can be found
* Param: string hostname, length (hostname needs no \0-end-marker),
* string to which dotted-quad-IP shall be written
* Return: 0 for success, >0 for failure
*/
// 256 for the DNS query payload, +4 for the result temporary
// Pointer to the payload
int i, h = hnlength;
long timeout;
// Setup the query data
query[QINDEX_NUMQUEST ]= 0;
query[QINDEX_NUMANSW ] = 0;
query[QINDEX_NUMAUTH ] = 0;
query[QINDEX_NUMADDIT ]= 0;
if ( h > 236 ) return 1; // Hostnames longer than 236 chars are refused.
// This is an arbitrary decision, SHOULD check
// what the RFCs say about that
for ( i = 0; i < h; ++i ) {
// Compose the query section's hostname - replacing dots (and
// preceding the string) with one-byte substring-length values
// (for the immediately following substring) - \0 terminated
if ( hostname[i] == '.' )
}
// First try an A query, if that
// won't work, try CNAME
printf ( "Resolving hostname [" );
printf ("]" );
printf ( ".." );
// Try MAX_CNAME_RECURSION CNAME queries maximally, if then no
// A record is found, assume the hostname to not be resolvable
// the query string
rx_qdrain(); // Clear NIC packet buffer -
// there won't be anything of interest *now*.
// If no answer comes in in a certain period of time, retry
i = await_reply ( await_dns,
// The parameters given are
// bits 15...8 of integer = Query type (low bits)
// bits 7...0 of integer = Query index (low bits)
// query + QINDEX_STORE_A points to the place
// where A records shall be stored (4 bytes);
// query + 12(QINDEX_QUESTION) points to where
// a CNAME should go in case one is received
if (i) break;
}
switch ( i ) {
case RET_GOT_ADDR: // Address successfully retrieved
(long)query[QINDEX_STORE_A ] +
return RET_DNS_OK;
case RET_RUN_CNAME_Q: // No A record found, try CNAME
break;
case RET_RUN_NEXT_A:
// Found a CNAME, now try A for the name it pointed to
for ( i = 0; query[QINDEX_QUESTION+i] != 0;
h = i - 1;
break;
case RET_CNAME_FAIL:
// Neither A nor CNAME gave a usable result
printf ("Host name cannot be resolved\n");
return RET_DNS_FAIL;
case RET_NOSUCHNAME:
default:
printf ( "Name resolution failed\n" );
return RET_DNS_FAIL;
}
// than 256 queries in one run
}
// To deep recursion
printf ( "CNAME recursion to deep - abort name resolver\n" );
return RET_DNS_FAIL;
}
#endif /* DNS_RESOLVER */