dns_client.h

DNS 的实现代码

/* 
 * resolver information.
 */

#define MAXNS             3   /* max number of name servers we'll track */
#define MAXDFLSRCH        3   /* number default domain levels to try */
#define MAXDNSRCH         6   /* max domains in the search path */ 
#define LOCALDOMAINPARTS  2   /* minimum levels in name that is local */
#define MINMATCHDOMAIN    2   /* minimun domain parts matching for NS selection */
#define RES_TIMEOUT       5   /* minimum seconds between retries */
#define RES_RETRY         2   /* max retries per server */
#define MAXDNSTRYS       12   /* this is arbitrary */
#define MAXQUERYDEPTH     5   /* this is also arbitrary */


#define MAXQS             5   /* max number of query state structures */
#define MAXIPS           25   /* max number of IP addresses in our pool */
#define MAXNAMES         25   /* max number of names in our pool */
#define MAXQUESTS         5   /* max number of DNS questions in pool */
#define MAXRRS           25   /* max number of DNS resource records */
#define MAXIPENTRYS       7   /* number of IP addresses we'll store for a host */
#define MAXMSGHOSTENT     7   /* max number of messages and dns_hostent structure */
#define ENTADDRS         15   /* number of addresses we'll track for internal queries */
#define MAXNLP            3   /* max number of nslookup resources */
#define MAXSOA            3   /* max number of SOA records */


#define BUFLEN           DNSMAX
#define DNSOFFSET        0
#define NSPORT           53

#define CNG_SEARCH       "search"
#define CNG_NS           "nameserver"
#define CONFIGFILE       "//isfs/init"
#define CONFIGBUFFER     ((MAXDNSRCH * NAMEMAX) + 1)

#define MS2SEC(x)        ((x) * 1000)


/* structure used for storing domain information */

typedef struct {
   int    timeout;                       /* time to wait before retransmit */
    int    retry;                         /* number of retransmit times */
    char   domain[NAMEMAX+1];             /* name of local domain */
    int    num_search;                    /* number of domains in the search list */
    char   search[MAXDNSRCH][NAMEMAX+1];  /* search list, list of domains */
    int    num_svr;                       /* number of name servers found */
    struct sockaddr_storage
           nsaddr[MAXNS];                 /* list of name server IP addresses */
} DnsDomain;


/*
 * SOCKEQUAL --
 *     Compares two sockaddr_storage structures.
 *
 * PARAMETERS
 *     sock1 - first address
 *     sock2 - second address
 *
 * PROTOTYPE:
 *     int SOCKEQUAL(struct sockaddr_storage *sock1, 
 *                   struct sockaddr_storage *sock2);
 * 
 * RETURNS TRUE if addresses are equal,
 *         FALSE otherwise
 */
#define SOCKEQUAL(sock1, sock2)                                 \
    ((sock1)->__ss_family == AF_INET ?                          \
     ((sock2)->__ss_family == AF_INET &&                        \
      memcmp(&((struct sockaddr_in *)(sock1))->sin_addr,        \
             &((struct sockaddr_in *)(sock2))->sin_addr,        \
             sizeof(struct in_addr)) == 0) :                    \
     ((sock1)->__ss_family == AF_INET6 ?                        \
      ((sock2)->__ss_family == AF_INET6 &&                      \
       memcmp(&((struct sockaddr_in6 *)(sock1))->sin6_addr,     \
              &((struct sockaddr_in6 *)(sock2))->sin6_addr,     \
              sizeof(struct in6_addr)) == 0) :                  \
      FALSE))

/* 
 * long2sock --
 *     This routine converts U32 IPv4 address into sockaddr_in structure
 *
 * PARAMETERS
 *     sock - storage for result
 *     ip   - IPv4 address to convert
 * 
 * RETURNS
 *     n/a
 */
extern void long2sock(OUT void *sock, IN U32 ip);

/* 
 * data2sock --
 *     This routine converts IPv6 address into sockaddr_in6 structure.
 *
 * PARAMETERS
 *     sock - storage for result
 *     data - address (pointer to an in6_addr structure or an array)
 *
 * RETURNS
 *     n/a
 */
extern void data2sock(OUT void *sock, IN void *data);

/*
 * sock2long --
 *     Converts a 'sockaddr_storage' structure into U32 IPv4 address.
 *     Note, family is not checked here, it is assumed here to be AF_INET.
 *     If the family is not AF_INET this inline routine will return
 *     weird result
 *
 * PARAMETERS
 *     sock - IPv4 address in sockaddr_storage form
 *
 * RETURNS
 *     IPv4 address converted in U32 type
 */
extern U32 sock2long(IN struct sockaddr_storage *sock);

/*
 * get_offset()
 *
 * this inline routine will strip the top two bits, (these just indicate the fact
 * that compression is used), and return a short that is the value of the remaining
 * 14 bits.  that value is an offset into the DNS message, first byte is 0.
 */
extern short get_offset(char *data);

/*
 * reverse_ip_addr()
 *
 * this routine takes an IP address as an unsigned long and will reverse it
 * and add on the "in-addr.arpa." so it can be used for a query.
 */
extern void reverse_ip_addr(U32 ip, char *rev);

/*
 * reverse_sockaddr_int --
 *     This routine reverses an IPv4 or IPv6 address
 *     and adds on the "ip6.int." (RFC 1886) or "in-addr.arpa" 
 *     so it can be used for a query.
 *
 * PARAMETERS
 *     ip   - ip address
 *     rev  - reversed IP address string
 *
 * RETURNS
 *     n/a
 */
extern void reverse_sockaddr_int(IN struct sockaddr_storage *ip, OUT char *rev);

/*
 * reverse_sockaddr_arpa --
 *     This routine reverses an IPv4 or IPv6 address
 *     and adds on the "ip6.arpa." (RFC 1886) or "in-addr.arpa" 
 *     so it can be used for a query.
 *
 * PARAMETERS
 *     ip   - ip address
 *     rev  - reversed IP address string
 *
 * RETURNS
 *     n/a
 */
extern void reverse_sockaddr_arpa(IN struct sockaddr_storage *ip, OUT char *rev);

/*
 * count_domain_parts()
 *
 * this routine will count the parts of a domain name.  we look for dots
 * in the name and base the count on that.
 *
 * return:  number of parts  (parts is parts)
 */
extern int count_domain_parts(const char *name);

/*
 * get_last_domain_parts()
 *
 * this routine will return a pointer to the last domain parts of a domain name.  it
 * will return NULL if there is an error.
 *
 * name    - the domain name, ex:  host.virata.com
 * tparts  - total number of parts in domain name, above ex. would be 3
 * lparts  - parts we're interested in, say 2 would give virata.com
 */
extern const char *get_last_domain_parts(const char *name, int tparts, int lparts);

/*
 * find_match_rrecord()
 *
 * this routine takes a pointer to the beginning of a DnsRRec list.  it goes
 * through the list looking for a RR that matches the correct type, given byrtype, 
 * and the domain name, dname.  it returns a pointer to that RR.
 *
 * return:  pointer to the first matching RR, or
 *          NULL if no match.
 */
extern DnsRRec *find_match_rrecord(const char *dname, DnsRRec *RRlist, U16 rtype);

/*
 * find_num_match()
 *
 * this routine will search through the entire list of RRs and count the
 * number that match the type and domain name.
 *
 * return:  number of matching.
 */
extern int find_num_match(const char *dname, DnsRRec *RRlist, U16 rtype);

/*
 * find_num_record()
 *
 * this routine will loop through the list of RRs given and count the number
 * of that type, (ex. SOA).  here the domain is not considered, just the record
 * type.
 *
 * return:  number of records of the given type.
 */
extern int find_num_record(DnsRRec *rrlist, U16 rtype);

/*
 * ip_string()
 *
 * this routine is used to construct a string to represent the IP address
 * in dotted decimal form from the long.
 */
extern void ip_string(struct sockaddr_storage *ip, char *str, int size);

/*
 * lowercase_copy()
 *
 * this routine will copy to destination from source.  it converts an upper
 * case characters to lower case before the copy.
 * NOTE: can't use the following statement: *to++ = tolower(*fptr++); in the
 * while loop  because of the tolower macro.
 */
extern void lowercase_copy(char *destination, const char *source);

/*
 * dns_copy_question()
 *
 * this routine will copy the contents of the from question to the to question.
 */
extern void dns_copy_question(DnsQuestion *qto, DnsQuestion *qfrom);

/*
 * Functions from dns_client_skt.c
 */
extern int dns_client_udp_send(U8                    *buffer,
                               int                    nbytes,
                               const struct sockaddr *to, 
                               socklen_t              tolen,
                               u_long                 timeout);

extern void dns_client_udp_receive(void);

#ifdef DNS_DEBUG
extern struct sockaddr_storage *dns_client_udp_get_sourceaddr(void);
#endif


extern U32  ipstring2long(const char *);
extern int  create_dns_message(U8 *, DnsMsg *);
extern int  parse_dns_message(U8 *, int, DnsMsg *);
extern void dnsmsg_cleanup(DnsMsg *);
extern void dns_free_rrlist(DnsRRec *);
extern void convert_addr_arpa(const char *, struct sockaddr_storage *);
extern U32  convert_addr_ipv4(const char *ptr);

extern void  dns_gethostbyname(ATMOS_MESSAGE *, DnsDomain *);
extern void  dns_gethostbyaddr(ATMOS_MESSAGE *, DnsDomain *);

extern void dns_getnodebyname(ATMOS_MESSAGE *, DnsDomain *);
extern void dns_gethostbyaddr6(ATMOS_MESSAGE *, DnsDomain *);

extern void  dns_udp_message(U8 *, int);
extern void  dns_node_query_reply(ATMOS_MESSAGE *);
extern void  dns_host_query_reply(ATMOS_MESSAGE *);
extern void  dns_addr_query_reply(ATMOS_MESSAGE *);
extern void  dns_addr6_query_reply(ATMOS_MESSAGE *);

extern int   count_match(Dcmp *, Dcmp *);
extern int   domain_compare(Dcmp *, Dcmp *, Dcmp *);
extern int   start_new_query(Qinfo_t *);

extern int   dns_validate_hostname(const char *);

extern void  dns_cache_init(void);

#ifdef DNS_DEBUG
extern void  print_dns_message(DnsMsg *);
extern void  print_dns_header(DnsHdr *);
#endif

extern void dns_flush_resolver_XX_cache(void);
extern void dns_show_resolver_XX_cache(void);
extern void dns_flush_resolver_XX_cache_byname(const char *);
extern void dns_XX_cache_init(void);

#endif