OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/trunk/rtos/ecos-2.0/packages/net/ns/dns/v2_0/include
    from Rev 27 to Rev 174
    ↔ Reverse comparison
  •

Rev 27 → Rev 174

/dns_impl.inl
0,0 → 1,619
#ifndef CYGONCE_NS_DNS_DNS_IMPL_H
#define CYGONCE_NS_DNS_DNS_IMPL_H
//=============================================================================
//
// dns_impl.inl
//
// DNS client code implementation.
//
//=============================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
//
// eCos is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later version.
//
// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// As a special exception, if other files instantiate templates or use macros
// or inline functions from this file, or you compile this file and link it
// with other works to produce a work based on this file, this file does not
// by itself cause the resulting work to be covered by the GNU General Public
// License. However the source code for this file must still be made available
// in accordance with section (3) of the GNU General Public License.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//=============================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): andrew.lunn
// Contributors:andrew.lunn, jskov
// Date: 2001-09-18
// Description: The code is kept in this separate file to allow it to be
// used from RedBoot.
//
//####DESCRIPTIONEND####
//
//=============================================================================
 
#include <cyg/ns/dns/dns_priv.h>
 
/* Validate a hostname is legal as defined in RFC 1035 */
static int
valid_hostname(const char *hostname)
{
const char * label;
const char * label_end;
if (!hostname) {
return false;
}
label = hostname;
while (*label) {
if (!isalpha(*label))
return false;
label_end = strchr(label, (int)'.') - 1;
if (label_end == (char *)-1) {
label_end = strchr(label, (int)'\0') - 1;
}
while (label != label_end) {
if (!isalnum(*label) && (*label != '-')) {
return false;
}
label++;
}
label = label_end+1; /* Move onto the . or the null. */
if (*label == '.') { /* Move over the . if there is one */
label++;
}
}
return true;
}
 
/* Build a qname structure. The structure consists of pairs of
<len><label> where <label> is eg ma in tux.ma.tech.ascom.ch. len is
the length of the label. */
static int
build_qname(char *ptr, const char *hostname)
{
const char *label = hostname;
char *end_label;
int total_len = 0;
int len;
while (*label) {
end_label = strchr(label, (int)'.') - 1;
if (end_label == (char *)-1) {
end_label = strchr(label, (int)'\0') - 1;
}
len = end_label - label + 1;
if (len > 63) {
return -1;
}
*ptr++ = (char) len; /* Put the length of the label */
memcpy(ptr, label, len); /* and now the label */
ptr += len;
total_len += len +1;
label = end_label+1; /* Move onto the . or the null. */
if (*label == '.') { /* Move over the . if there is one */
label++;
}
}
*ptr = 0; /* Add the last length of zero
to mark the end */
return (total_len+1);
}
 
/* Given a pointer to a qname, find the length of the qname. This is
the number of bytes needed to represent the qname, not the length
of the name. A qname is terminated by either a 00, or a pointer
into another qname. This pointer has the top two bits set. */
static int
qname_len(unsigned char * qname)
{
unsigned char * ptr = qname;
while ((*ptr != 0) && ((*ptr & 0xc0) != 0xc0)) {
ptr += *ptr + 1;
}
/* Pointers are two bytes */
if ((*ptr & 0xc0) == 0xc0) {
ptr++;
}
ptr++; /* Skip over the trailing byte */
 
return (ptr - qname);
}
 
/* Build a real name from a qname. Alloc the memory needed and return
it. Return NULL on error */
char *
real_name(char *msg, unsigned char *qname)
{
unsigned char * ptr = qname;
char * name;
char * label;
int len = 0;
int offset;
 
/* First pass works out the length of the name */
while (*ptr != 0) {
if ((*ptr & 0xc0) == 0xc0) {
/* pointer to somewhere else. Follow the pointer */
offset = ((*ptr & 0x3f) << 8) | *(ptr+1);
ptr = msg + offset;
} else {
len += *ptr + 1;
ptr += *ptr + 1;
}
}
 
/* Now allocate the memory needed and copy the host name into it */
name = alloc_string(len+1);
if (name) {
label = name;
ptr = qname;
while (*ptr != 0) {
if ((*ptr & 0xc0) == 0xc0) {
/* pointer to somewhere else. Follow the pointer */
offset = ((*ptr & 0x3f) << 8) | *(ptr+1);
ptr = msg + offset;
} else {
len = *ptr;
memcpy(label, (ptr+1), len);
label += len;
*label++ = '.';
ptr += *ptr + 1;
}
}
*label = '\0';
}
return name;
}
 
/* Build a query message which can be sent to the server. If something
goes wrong return -1, otherwise the length of the query message */
static int
build_query(char * msg, const char * hostname, short rr_type)
{
struct dns_header *dns_hdr;
char *ptr;
int len;
 
/* Fill out the header */
dns_hdr = (struct dns_header *) msg;
dns_hdr->id = htons(id++);
dns_hdr->rd = true;
dns_hdr->opcode = DNS_QUERY;
dns_hdr->qdcount = htons(1);
/* Now the question we want to ask */
ptr = (char *)&dns_hdr[1];
 
len = build_qname(ptr, hostname);
 
if (len < 0) {
h_errno = NO_RECOVERY;
return -1;
}
ptr += len;
 
/* Set the type and class fields */
*ptr++ = (rr_type >> 8) & 0xff;
*ptr++ = rr_type & 0xff;
*ptr++ = (DNS_CLASS_IN >> 8) & 0xff;
*ptr++ = DNS_CLASS_IN & 0xff;
 
len = ptr - msg;
 
return len;
}
 
/* Check if the hostname is actually of dot format. If so convert it
and return host entity structure. If not, return NULL. */
static struct hostent *
dot_hostname(const char *hostname)
{
struct hostent *hent = NULL;
struct in_addr addr;
 
if (inet_aton(hostname, &addr)) {
hent = alloc_hent();
if (hent) {
memcpy(hent->h_addr_list[0], &addr, sizeof(struct in_addr));
hent->h_addrtype = AF_INET;
hent->h_length = sizeof(struct in_addr);
hent->h_name = alloc_string(strlen(hostname)+1);
if (!hent->h_name) {
free_hent(hent);
return NULL;
}
strcpy(hent->h_name, hostname);
}
}
return hent;
}
 
/* Decode the answer from the server. Returns NULL if failed, or
a hostent structure containing different data depending on the
query type:
DNS_TYPE_A:
h_name: a pointer to the hostname
h_addr_list[0]: a pointer to in_addr structure
DNS_TYPE_PTR:
h_name: a pointer to the hostname
h_addr_list[0]: a pointer to an empty in_addr structure. Caller
must fill out!
*/
static struct hostent *
parse_answer(char * msg, short rr_type)
{
static struct hostent *hent;
struct dns_header *dns_hdr;
struct resource_record rr, *rr_p = NULL;
char *qname = NULL;
char *ptr;
 
dns_hdr = (struct dns_header *)msg;
 
if (DNS_REPLY_NAME_ERROR == dns_hdr->rcode) {
h_errno = HOST_NOT_FOUND;
return NULL;
}
 
if ((dns_hdr->qr != 1) ||
(dns_hdr->opcode != DNS_QUERY) ||
(dns_hdr->rcode != DNS_REPLY_NOERR)) {
h_errno = NO_RECOVERY;
return NULL;
}
dns_hdr->ancount = ntohs(dns_hdr->ancount);
dns_hdr->qdcount = ntohs(dns_hdr->qdcount);
ptr = (char *)&dns_hdr[1];
 
/* Skip over the query section */
if (dns_hdr->qdcount > 0) {
while (dns_hdr->qdcount) {
ptr += qname_len(ptr);
ptr += 4; /* skip type & class */
dns_hdr->qdcount--;
}
}
/* Skip over the answers resource records to find an answer of the
correct type. */
while (dns_hdr->ancount) {
qname = ptr;
ptr += qname_len(ptr);
rr_p = (struct resource_record *)ptr;
memcpy(&rr, ptr, sizeof(rr));
if ((rr.rr_type == htons(rr_type)) &&
(rr.class == htons(DNS_CLASS_IN))) {
break;
}
ptr += sizeof(struct resource_record) - sizeof(rr.rdata) + ntohs(rr.rdlength);
dns_hdr->ancount--;
}
 
/* If we found one. decode it */
if (dns_hdr->ancount > 0) {
hent = alloc_hent();
if (!hent)
return NULL;
switch (rr_type) {
case DNS_TYPE_A:
hent->h_name = real_name(msg, qname);
if (!hent->h_name) {
free_hent(hent);
return NULL;
}
memcpy(hent->h_addr_list[0], rr_p->rdata, sizeof(struct in_addr));
hent->h_addrtype = AF_INET;
hent->h_length = sizeof(struct in_addr);
return hent;
case DNS_TYPE_PTR:
hent->h_name = real_name(msg, rr_p->rdata);
if (!hent->h_name) {
free_hent(hent);
return NULL;
}
hent->h_addrtype = AF_INET;
hent->h_length = sizeof(struct in_addr);
return hent;
default:
free_hent(hent);
}
}
h_errno = NO_DATA;
return NULL;
}
 
/* Given an address, find out the hostname. */
struct hostent *
gethostbyaddr(const char *addr, int len, int type)
{
unsigned char msg[MAXDNSMSGSIZE];
char hostname[40];
struct hostent * hent;
 
CYG_REPORT_FUNCNAMETYPE( "gethostbyaddr", "returning %08x" );
CYG_REPORT_FUNCARG3( "addr=%08x, len=%d, type=%d", addr, len, type );
 
if ( !addr || 0 == len) {
CYG_REPORT_RETVAL( NULL );
return NULL;
}
 
CYG_CHECK_DATA_PTR( addr, "addr is not a valid pointer!" );
 
/* Has the socket to the DNS server been opened? */
if (s < 0) {
CYG_REPORT_RETVAL( NULL );
return NULL;
}
 
/* See if there is an answer to an old query. If so free the memory
it uses. */
free_stored_hent();
 
/* Only IPv4 addresses accepted */
if ((type != AF_INET) || (len != sizeof(struct in_addr))) {
CYG_REPORT_RETVAL( NULL );
return NULL;
}
 
cyg_drv_mutex_lock(&dns_mutex);
 
/* Build the 'hostname' we want to lookup. */
sprintf(hostname, "%d.%d.%d.%d.IN-ADDR.ARPA.",
(unsigned char)addr[3],
(unsigned char)addr[2],
(unsigned char)addr[1],
(unsigned char)addr[0]);
memset(msg, 0, sizeof(msg));
/* Build a PTR type request using the hostname */
len = build_query(msg, hostname, DNS_TYPE_PTR);
if (len < 0) {
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( NULL );
return NULL;
}
 
/* Send the request and wait for an answer */
len = send_recv(msg, len, sizeof(msg));
if (len < 0) {
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( NULL );
return NULL;
}
 
/* Fill in the missing address */
hent = parse_answer(msg, DNS_TYPE_PTR);
if (hent) {
memcpy(hent->h_addr_list[0], addr, sizeof(struct in_addr));
store_hent(hent);
}
cyg_drv_mutex_unlock(&dns_mutex);
 
CYG_REPORT_RETVAL( hent );
return hent;
}
 
/* Given a hostname find out the IP address */
struct hostent *
gethostbyname(const char * hostname)
{
unsigned char msg[MAXDNSMSGSIZE];
char name[256];
struct hostent *hent;
int len;
 
CYG_REPORT_FUNCNAMETYPE( "gethostbyname", "returning %08x" );
CYG_REPORT_FUNCARG1( "hostname=%08x", hostname );
 
if ( !hostname ) {
CYG_REPORT_RETVAL( NULL );
return NULL;
}
 
CYG_CHECK_DATA_PTR( hostname, "hostname is not a valid pointer!" );
 
/* Has the socket to the DNS server been opened? */
if (s < 0) {
CYG_REPORT_RETVAL( NULL );
return NULL;
}
 
/* See if there is an answer to an old query. If so free the memory
it uses */
free_stored_hent();
if (!valid_hostname(hostname)) {
/* It could be a dot address */
hent = dot_hostname(hostname);
store_hent(hent);
CYG_REPORT_RETVAL( hent );
return hent;
}
 
cyg_drv_mutex_lock(&dns_mutex);
 
/* First try the name as passed in */
memset(msg, 0, sizeof(msg));
len = build_query(msg, hostname, DNS_TYPE_A);
if (len < 0) {
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( NULL );
return NULL;
}
/* Send the query and wait for an answer */
len = send_recv(msg, len, sizeof(msg));
if (len < 0) {
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( NULL );
return NULL;
}
/* Decode the answer */
hent = parse_answer(msg, DNS_TYPE_A);
if (hent) {
cyg_drv_mutex_unlock(&dns_mutex);
store_hent(hent);
CYG_REPORT_RETVAL( hent );
return hent;
}
 
/* If no match, try appending the domainname if we have one */
if (domainname) {
if ((strlen(hostname) + strlen(domainname)) > 254) {
h_errno = NO_RECOVERY;
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( NULL );
return NULL;
}
strcpy(name, hostname);
strcat(name, ".");
strcat(name, domainname);
memset(msg, 0, sizeof(msg));
len = build_query(msg, name, DNS_TYPE_A);
if (len < 0) {
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( NULL );
return NULL;
}
/* Send the query and wait for an answer */
len = send_recv(msg, len, sizeof(msg));
if (len < 0) {
cyg_drv_mutex_unlock(&dns_mutex);
CYG_REPORT_RETVAL( NULL );
return NULL;
}
/* Decode the answer */
hent = parse_answer(msg, DNS_TYPE_A);
}
 
cyg_drv_mutex_unlock(&dns_mutex);
store_hent(hent);
CYG_REPORT_RETVAL( hent );
return hent;
}
 
/* Set the domain names, as used by the DNS server */
int
setdomainname(const char *name, size_t len)
{
char * ptr;
 
CYG_REPORT_FUNCNAMETYPE( "setdomainname", "returning %d" );
CYG_REPORT_FUNCARG2( "name=%08x, len=%d", name, len );
 
if ((len < 0) || (len > 255)) {
h_errno = NO_RECOVERY;
CYG_REPORT_RETVAL( -1 );
return -1;
}
if (len != 0) {
CYG_CHECK_DATA_PTR( name, "name is not a valid pointer!" );
ptr = alloc_string(len+1);
if (!ptr) {
CYG_REPORT_RETVAL( -1 );
return -1;
}
memcpy(ptr, name, len);
ptr[len]=0;
} else {
ptr = NULL;
}
if (domainname) {
free_string(domainname);
}
domainname = ptr;
CYG_REPORT_RETVAL( 0 );
return 0;
}
 
/* Return the domain name as used by the DNS server */
int
getdomainname(char *name, size_t len)
{
CYG_REPORT_FUNCNAMETYPE( "getdomainname", "returning %d" );
CYG_REPORT_FUNCARG2( "name=%08x, len=%d", name, len );
 
if ( !name || 0 == len) {
CYG_REPORT_RETVAL( -1 );
return -1;
}
 
CYG_CHECK_DATA_PTR( name, "name is not a valid pointer!" );
 
/* No domainname set, return a 0 */
if (!domainname) {
if (len == 0) {
h_errno = HOST_NOT_FOUND;
CYG_REPORT_RETVAL( -1 );
return -1;
}
name[0]='\0';
} else {
if ((strlen(domainname) + 1) > len) {
h_errno = NO_RECOVERY;
CYG_REPORT_RETVAL( -1 );
return -1;
}
strncpy(name, domainname, len);
}
CYG_REPORT_RETVAL( 0 );
return 0;
}
 
int h_errno = DNS_SUCCESS;
 
const char*
hstrerror(int err)
{
CYG_REPORT_FUNCNAMETYPE( "hstrerror", "returning %08x" );
CYG_REPORT_FUNCARG1( "err=%d", err );
 
switch (err) {
case DNS_SUCCESS:
return "No error";
case HOST_NOT_FOUND:
return "No such host is known";
case TRY_AGAIN:
return "Timeout";
case NO_RECOVERY:
return "Server failure or invalid input";
case NO_DATA:
return "No data for type";
default:
return "Uknown error";
}
}
 
//-----------------------------------------------------------------------------
#endif // CYGONCE_NS_DNS_DNS_IMPL_H
// End of dns_impl.h
/dns.h
0,0 → 1,88
#ifndef CYGONCE_NS_DNS_DNS_H
#define CYGONCE_NS_DNS_DNS_H
//=============================================================================
//
// dns.h
//
// DNS client code.
//
//=============================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
//
// eCos is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later version.
//
// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// As a special exception, if other files instantiate templates or use macros
// or inline functions from this file, or you compile this file and link it
// with other works to produce a work based on this file, this file does not
// by itself cause the resulting work to be covered by the GNU General Public
// License. However the source code for this file must still be made available
// in accordance with section (3) of the GNU General Public License.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//=============================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): andrew.lunn
// Contributors:andrew.lunn, jskov
// Date: 2001-09-18
//
//####DESCRIPTIONEND####
//
//=============================================================================
 
#include <network.h>
#include <netinet/in.h>
 
#ifndef _POSIX_SOURCE
/* Initialise the DNS client with the address of the server */
externC int cyg_dns_res_init(struct in_addr *dns_server);
externC int getdomainname(char *name, size_t len);
externC int setdomainname(const char *name, size_t len);
#endif
 
// Host name / IP mapping
struct hostent {
char *h_name; /* official name of host */
char **h_aliases; /* alias list */
int h_addrtype; /* host address type */
int h_length; /* length of address */
char **h_addr_list; /* list of addresses */
};
#define h_addr h_addr_list[0] /* for backward compatibility */
 
externC struct hostent *gethostbyname(const char *host);
externC struct hostent *gethostbyaddr(const char *addr, int len, int type);
 
// Error reporting
externC int h_errno;
externC const char* hstrerror(int err);
 
#define DNS_SUCCESS 0
#define HOST_NOT_FOUND 1
#define TRY_AGAIN 2
#define NO_RECOVERY 3
#define NO_DATA 4
 
//-----------------------------------------------------------------------------
#endif // CYGONCE_NS_DNS_DNS_H
// End of dns.h
/dns_priv.h
0,0 → 1,127
#ifndef CYGONCE_NS_DNS_DNS_PRIV_H
#define CYGONCE_NS_DNS_DNS_PRIV_H
//=============================================================================
//
// dns-priv.h
//
// Private DNS client definitions.
//
//=============================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
//
// eCos is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later version.
//
// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// As a special exception, if other files instantiate templates or use macros
// or inline functions from this file, or you compile this file and link it
// with other works to produce a work based on this file, this file does not
// by itself cause the resulting work to be covered by the GNU General Public
// License. However the source code for this file must still be made available
// in accordance with section (3) of the GNU General Public License.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//=============================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): andrew.lunn
// Contributors:andrew.lunn, jskov
// Date: 2001-09-18
//
//####DESCRIPTIONEND####
//
//=============================================================================
 
struct dns_header {
#if (CYG_BYTEORDER == CYG_LSBFIRST)
unsigned id :16; /* query identification number */
/* fields in third byte */
unsigned rd :1; /* recursion desired */
unsigned tc :1; /* truncated message */
unsigned aa :1; /* authoritive answer */
unsigned opcode :4; /* purpose of message */
unsigned qr :1; /* response flag */
/* fields in fourth byte */
unsigned rcode :4; /* response code */
unsigned cd: 1; /* checking disabled by resolver */
unsigned ad: 1; /* authentic data from named */
unsigned unused :1; /* unused bits */
unsigned ra :1; /* recursion available */
/* remaining bytes */
unsigned qdcount :16; /* number of question entries */
unsigned ancount :16; /* number of answer entries */
unsigned nscount :16; /* number of authority entries */
unsigned arcount :16; /* number of resource entries */
#else
unsigned id :16; /* query identification number */
/* fields in third byte */
unsigned qr :1; /* response flag */
unsigned opcode :4; /* purpose of message */
unsigned aa :1; /* authoritive answer */
unsigned tc :1; /* truncated message */
unsigned rd :1; /* recursion desired */
/* fields in fourth byte */
unsigned ra :1; /* recursion available */
unsigned unused :1; /* unused bits */
unsigned ad: 1; /* authentic data from named */
unsigned cd: 1; /* checking disabled by resolver */
unsigned rcode :4; /* response code */
/* remaining bytes */
unsigned qdcount :16; /* number of question entries */
unsigned ancount :16; /* number of answer entries */
unsigned nscount :16; /* number of authority entries */
unsigned arcount :16; /* number of resource entries */
#endif
};
 
struct resource_record {
unsigned rr_type : 16; /* Type of resourse */
unsigned class : 16; /* Class of resource */
unsigned ttl : 32; /* Time to live of this record */
unsigned rdlength: 16; /* Lenght of data to follow */
char rdata [2]; /* Resource DATA */
};
 
/* Opcodes */
#define DNS_QUERY 0 /* Standard query */
#define DNS_IQUERY 1 /* Inverse query */
#define DNS_STATUS 2 /* Name server status */
#define DNS_NOTIFY 4 /* Zone change notification */
#define DNS_UPDATE 5 /* Zone update message */
 
/* DNS TYPEs */
#define DNS_TYPE_A 1 /* Host address */
#define DNS_TYPE_NS 2 /* Authoritative name server */
#define DNS_TYPE_CNAME 5 /* Canonical name for an alias */
#define DNS_TYPE_PTR 12 /* Domain name pointer */
 
/* DNS CLASSs */
#define DNS_CLASS_IN 1 /* Internet */
 
/* DNS reply codes */
#define DNS_REPLY_NOERR 0
#define DNS_REPLY_NAME_ERROR 3
 
#define MAXDNSMSGSIZE 512
 
//-----------------------------------------------------------------------------
#endif // CYGONCE_NS_DNS_DNS_PRIV_H
// End of dns-priv.h

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.