/*

 * Copyright (C) 2001-2003 FhG Fokus

 *

 * This file is part of Kamailio, a free SIP server.

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 *

 * Kamailio 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 of the License, or

 * (at your option) any later version

 *

 * Kamailio 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 */

/*!

 * \file

 * \brief Kamailio core :: DNS resolver

 * \ingroup core

 * Module: \ref core

 */

#include <sys/types.h>

#include <netinet/in.h>

#include <arpa/nameser.h>

#include <resolv.h>

#include <string.h>

/*

 * Older glibc < 2.25 does not include T_OPT in nameser_compat.h yet.

 * On alpine linux musl library it is also not defined. There is no

 * musl feature test macro, so we look for glibc instead.

 */

#if(defined __GLIBC__ && __GLIBC__ == 2 && __GLIBC_MINOR__ < 25) \

    || !defined __GLIBC__

#ifndef T_OPT

#define T_OPT ns_t_opt

#endif

#endif

#include "resolve.h"

#include "compiler_opt.h"

#include "dprint.h"

#include "mem/mem.h"

#include "ip_addr.h"

#include "ut.h"

#include "error.h"

#include "globals.h" /* tcp_disable, tls_disable a.s.o */

#include "cfg_core.h"

#include "socket_info.h"

#ifdef USE_DNS_CACHE

#include "dns_cache.h"

#endif

#define KSR_IPADDR_LIST_SIZE 6

static ip_addr_t _ksr_ipaddr_list[KSR_IPADDR_LIST_SIZE];

static int _ksr_ipaddr_list_idx = 0;

static ip_addr_t *get_next_ipaddr_buf(void)

{

  ip_addr_t *ipb;

  ipb = &_ksr_ipaddr_list[_ksr_ipaddr_list_idx];

  _ksr_ipaddr_list_idx = (_ksr_ipaddr_list_idx + 1) % KSR_IPADDR_LIST_SIZE;

  return ipb;

}

/* counters framework */

struct dns_counters_h dns_cnts_h;

counter_def_t dns_cnt_defs[] = {

    {&dns_cnts_h.failed_dns_req, "failed_dns_request", 0, 0, 0,

        "incremented each time a DNS request has failed."},

    {&dns_cnts_h.slow_dns_req, "slow_dns_request", 0, 0, 0,

        "incremented each time a DNS request took longer than "

        "dns_slow_query_ms."},

    {0, 0, 0, 0, 0, 0}};

#ifdef USE_NAPTR

static int naptr_proto_pref[PROTO_LAST + 1];

#endif

static int srv_proto_pref[PROTO_LAST + 1];

#ifdef USE_NAPTR

static void init_naptr_proto_prefs()

{

  int ignore_rfc, udp, tcp, tls, sctp;

  if((PROTO_UDP > PROTO_LAST) || (PROTO_TCP > PROTO_LAST)

      || (PROTO_TLS > PROTO_LAST) || (PROTO_SCTP > PROTO_LAST)) {

    BUG("init_naptr_proto_prefs: array too small \n");

    return;

  }

  ignore_rfc = cfg_get(core, core_cfg, dns_naptr_ignore_rfc);

  udp = cfg_get(core, core_cfg, dns_udp_pref);

  tcp = cfg_get(core, core_cfg, dns_tcp_pref);

  tls = cfg_get(core, core_cfg, dns_tls_pref);

  sctp = cfg_get(core, core_cfg, dns_sctp_pref);

  /* Old implementation ignored the Order field in the NAPTR RR and

   * thus violated a MUST in RFC 2915. Currently still the default. */

  if(ignore_rfc) {

    naptr_proto_pref[PROTO_UDP] = udp;

    naptr_proto_pref[PROTO_TCP] = tcp;

    naptr_proto_pref[PROTO_TLS] = tls;

    naptr_proto_pref[PROTO_SCTP] = sctp;

  } else {

    /* If value is less than 0, proto is disabled, otherwise

     * ignored. */

    naptr_proto_pref[PROTO_UDP] = udp < 0 ? udp : 1;

    naptr_proto_pref[PROTO_TCP] = tcp < 0 ? tcp : 1;

    naptr_proto_pref[PROTO_TLS] = tls < 0 ? tls : 1;

    naptr_proto_pref[PROTO_SCTP] = sctp < 0 ? sctp : 1;

  }

}

#endif /* USE_NAPTR */

static void init_srv_proto_prefs()

{

  if((PROTO_UDP > PROTO_LAST) || (PROTO_TCP > PROTO_LAST)

      || (PROTO_TLS > PROTO_LAST) || (PROTO_SCTP > PROTO_LAST)) {

    BUG("init_srv_proto_prefs: array too small \n");

    return;

  }

  srv_proto_pref[PROTO_UDP] = cfg_get(core, core_cfg, dns_udp_pref);

  srv_proto_pref[PROTO_TCP] = cfg_get(core, core_cfg, dns_tcp_pref);

  srv_proto_pref[PROTO_TLS] = cfg_get(core, core_cfg, dns_tls_pref);

  srv_proto_pref[PROTO_SCTP] = cfg_get(core, core_cfg, dns_sctp_pref);

}

#ifdef DNS_WATCHDOG_SUPPORT

static on_resolv_reinit on_resolv_reinit_cb = NULL;

/* register the callback function */

int register_resolv_reinit_cb(on_resolv_reinit cb)

{

  if(on_resolv_reinit_cb) {

    LM_ERR("callback function has been already registered\n");

    return -1;

  }

  on_resolv_reinit_cb = cb;

  return 0;

}

#endif

/* counter init function

  must be called before fork

*/

static int stat_init(void)

{

  if(counter_register_array("dns", dns_cnt_defs) < 0)

    goto error;

  return 0;

error:

  return -1;

}

/** init. the resolver

 * params: retr_time  - time before retransmitting (must be >0)

 *         retr_no    - retransmissions number

 *         servers_no - how many dns servers will be used

 *                      (from the one listed in /etc/resolv.conf)

 *         search     - if 0 the search list in /etc/resolv.conf will

 *                      be ignored (HINT: even if you don't have a

 *                      search list in resolv.conf, it's still better

 *                      to set search to 0, because an empty seachlist

 *                      means in fact search "" => it takes more time)

 * If any of the parameters <0, the default (system specific) value

 * will be used. See also resolv.conf(5).

 * returns: 0 on success, -1 on error

 */

static int _resolv_init(void)

{

  dns_func.sr_res_init();

#ifdef HAVE_RESOLV_RES

  if(cfg_get(core, core_cfg, dns_retr_time) > 0)

    _res.retrans = cfg_get(core, core_cfg, dns_retr_time);

  if(cfg_get(core, core_cfg, dns_retr_no) > 0)

    _res.retry = cfg_get(core, core_cfg, dns_retr_no);

  if((cfg_get(core, core_cfg, dns_servers_no) >= 0)

      && (cfg_get(core, core_cfg, dns_servers_no) < _res.nscount))

    _res.nscount = cfg_get(core, core_cfg, dns_servers_no);

  if(cfg_get(core, core_cfg, dns_search_list) == 0)

    _res.options &= ~(RES_DEFNAMES | RES_DNSRCH);

#else

#warning "no resolv timeout support"

  LM_WARN("no resolv options support - resolv options will be ignored\n");

#endif

  return 0;

}

/** wrapper function to initialize the resolver at startup */

int resolv_init(void)

{

  int res = -1;

  _resolv_init();

  reinit_proto_prefs(NULL, NULL);

  /* init counter API only at startup

   * This function must be called before DNS cache init method (if available)

   */

  res = stat_init();

  return res;

}

/** wrapper function to reinitialize the resolver

 * This function must be called by each child process whenever

 * a resolver option changes

 */

void resolv_reinit(str *gname, str *name)

{

  _resolv_init();

#ifdef DNS_WATCHDOG_SUPPORT

  if(on_resolv_reinit_cb)

    on_resolv_reinit_cb(name);

#endif

  LM_DBG("DNS resolver has been reinitialized\n");

}

/** fixup function for dns_reinit variable

 * (resets the variable to 0)

 */

int dns_reinit_fixup(void *handle, str *gname, str *name, void **val)

{

  *val = (void *)(long)0;

  return 0;

}

/** wrapper function to recalculate the naptr and srv protocol preferences */

void reinit_proto_prefs(str *gname, str *name)

{

#ifdef USE_NAPTR

  init_naptr_proto_prefs();

#endif

  init_srv_proto_prefs();

}

/** fixup function for dns_try_ipv6

 * verifies that Kamailio really listens on an ipv6 interface

 */

int dns_try_ipv6_fixup(void *handle, str *gname, str *name, void **val)

{

  if((int)(long)(*val) && !(socket_types & SOCKET_T_IPV6)) {

    LM_ERR("SER does not listen on any ipv6 interface, "

         "there is no point in resolving ipv6 addresses\n");

    return -1;

  }

  return 0;

}

/**  skips over a domain name in a dns message

 *  (it can be  a sequence of labels ending in \0, a pointer or

 *   a sequence of labels ending in a pointer -- see rfc1035

 *   returns pointer after the domain name or null on error*/

unsigned char *dns_skipname(unsigned char *p, unsigned char *end)

{

  while(p < end) {

    /* check if \0 (root label length) */

    if(*p == 0) {

      p += 1;

      break;

    }

    /* check if we found a pointer */

    if(((*p) & 0xc0) == 0xc0) {

      /* if pointer skip over it (2 bytes) & we found the end */

      p += 2;

      break;

    }

    /* normal label */

    p += *p + 1;

  }

  return (p > end) ? 0 : p;

}

/** parses the srv record into a srv_rdata structure

 *   msg   - pointer to the dns message

 *   end   - pointer to the end of the message

 *   eor   - pointer to the end of the record/rdata

 *   rdata - pointer  to the rdata part of the srv answer

 * returns 0 on error, or a dyn. alloc'ed srv_rdata structure

 *

 * SRV rdata format:

 *            111111

 *  0123456789012345

 * +----------------+

 * |     priority   |

 * |----------------|

 * |     weight     |

 * |----------------|

 * |   port number  |

 * |----------------|

 * |                |

 * ~      name      ~

 * |                |

 * +----------------+

 */

struct srv_rdata *dns_srv_parser(unsigned char *msg, unsigned char *end,

    unsigned char *eor, unsigned char *rdata)

{

  struct srv_rdata *srv;

  unsigned short priority;

  unsigned short weight;

  unsigned short port;

  int len;

  char name[MAX_DNS_NAME];

  srv = 0;

  if((rdata + 6 + 1) > eor)

    goto error;

  memcpy((void *)&priority, rdata, 2);

  memcpy((void *)&weight, rdata + 2, 2);

  memcpy((void *)&port, rdata + 4, 2);

  rdata += 6;

  if(dn_expand(msg, end, rdata, name, MAX_DNS_NAME - 1) < 0)

    goto error;

  len = strlen(name);

  if(len > 255)

    goto error;

  /* alloc enought space for the struct + null terminated name */

  srv = pkg_malloc(sizeof(struct srv_rdata) - 1 + len + 1);

  if(srv == 0) {

    PKG_MEM_ERROR;

    goto error;

  }

  srv->priority = ntohs(priority);

  srv->weight = ntohs(weight);

  srv->port = ntohs(port);

  srv->name_len = len;

  memcpy(srv->name, name, srv->name_len);

  srv->name[srv->name_len] = 0;

  return srv;

error:

  if(srv)

    pkg_free(srv);

  return 0;

}

/** parses the naptr record into a naptr_rdata structure

 *   msg   - pointer to the dns message

 *   end   - pointer to the end of the message

 *   eor   - pointer to the end of the record/rdata

 *   rdata - pointer  to the rdata part of the naptr answer

 * returns 0 on error, or a dyn. alloc'ed naptr_rdata structure */

/* NAPTR rdata format:

 *            111111

 *  0123456789012345

 * +----------------+

 * |      order     |

 * |----------------|

 * |   preference   |

 * |----------------|

 * ~     flags      ~

 * |   (string)     |

 * |----------------|

 * ~    services    ~

 * |   (string)     |

 * |----------------|

 * ~    regexp      ~

 * |   (string)     |

 * |----------------|

 * ~  replacement   ~

   |    (name)      |

 * +----------------+

 */

struct naptr_rdata *dns_naptr_parser(unsigned char *msg, unsigned char *end,

    unsigned char *eor, unsigned char *rdata)

{

  struct naptr_rdata *naptr;

  unsigned char *flags;

  unsigned char *services;

  unsigned char *regexp;

  unsigned short order;

  unsigned short pref;

  unsigned char flags_len;

  unsigned char services_len;

  unsigned char regexp_len;

  int len;

  char repl[MAX_DNS_NAME];

  naptr = 0;

  if((rdata + 7 + 1) > eor)

    goto error;

  memcpy((void *)&order, rdata, 2);

  memcpy((void *)&pref, rdata + 2, 2);

  flags_len = rdata[4];

  if((rdata + 7 + 1 + flags_len) > eor)

    goto error;

  flags = rdata + 5;

  services_len = rdata[5 + flags_len];

  if((rdata + 7 + 1 + flags_len + services_len) > eor)

    goto error;

  services = rdata + 6 + flags_len;

  regexp_len = rdata[6 + flags_len + services_len];

  if((rdata + 7 + 1 + flags_len + services_len + regexp_len) > eor)

    goto error;

  regexp = rdata + 7 + flags_len + services_len;

  rdata = rdata + 7 + flags_len + services_len + regexp_len;

  if(dn_expand(msg, end, rdata, repl, MAX_DNS_NAME - 1) == -1)

    goto error;

  len = strlen(repl);

  if(len > 255)

    goto error;

  naptr = pkg_malloc(sizeof(struct naptr_rdata) + flags_len + services_len

             + regexp_len + len + 1 - 1);

  if(naptr == 0) {

    PKG_MEM_ERROR;

    goto error;

  }

  naptr->skip_record = 0;

  naptr->order = ntohs(order);

  naptr->pref = ntohs(pref);

  naptr->flags = &naptr->str_table[0];

  naptr->flags_len = flags_len;

  memcpy(naptr->flags, flags, naptr->flags_len);

  naptr->services = &naptr->str_table[flags_len];

  naptr->services_len = services_len;

  memcpy(naptr->services, services, naptr->services_len);

  naptr->regexp = &naptr->str_table[flags_len + services_len];

  naptr->regexp_len = regexp_len;

  memcpy(naptr->regexp, regexp, naptr->regexp_len);

  naptr->repl = &naptr->str_table[flags_len + services_len + regexp_len];

  naptr->repl_len = len;

  memcpy(naptr->repl, repl, len);

  naptr->repl[len] = 0; /* null term. */

  return naptr;

error:

  if(naptr)

    pkg_free(naptr);

  return 0;

}

/** parses a CNAME record into a cname_rdata structure */

struct cname_rdata *dns_cname_parser(

    unsigned char *msg, unsigned char *end, unsigned char *rdata)

{

  struct cname_rdata *cname;

  int len;

  char name[MAX_DNS_NAME];

  cname = 0;

  if(dn_expand(msg, end, rdata, name, MAX_DNS_NAME - 1) == -1)

    goto error;

  len = strlen(name);

  if(len > 255)

    goto error;

  /* alloc sizeof struct + space for the null terminated name */

  cname = pkg_malloc(sizeof(struct cname_rdata) - 1 + len + 1);

  if(cname == 0) {

    PKG_MEM_ERROR;

    goto error;

  }

  cname->name_len = len;

  memcpy(cname->name, name, cname->name_len);

  cname->name[cname->name_len] = 0;

  return cname;

error:

  if(cname)

    pkg_free(cname);

  return 0;

}

/** parses an A record rdata into an a_rdata structure

 * returns 0 on error or a dyn. alloc'ed a_rdata struct

 */

struct a_rdata *dns_a_parser(unsigned char *rdata, unsigned char *eor)

{

  struct a_rdata *a;

  if(rdata + 4 > eor)

    goto error;

  a = (struct a_rdata *)pkg_malloc(sizeof(struct a_rdata));

  if(a == 0) {

    PKG_MEM_ERROR;

    goto error;

  }

  memcpy(a->ip, rdata, 4);

  return a;

error:

  return 0;

}

/** parses an AAAA (ipv6) record rdata into an aaaa_rdata structure

 * returns 0 on error or a dyn. alloc'ed aaaa_rdata struct */

struct aaaa_rdata *dns_aaaa_parser(unsigned char *rdata, unsigned char *eor)

{

  struct aaaa_rdata *aaaa;

  if(rdata + 16 > eor)

    goto error;

  aaaa = (struct aaaa_rdata *)pkg_malloc(sizeof(struct aaaa_rdata));

  if(aaaa == 0) {

    PKG_MEM_ERROR;

    goto error;

  }

  memcpy(aaaa->ip6, rdata, 16);

  return aaaa;

error:

  return 0;

}

/** parses a TXT record into a txt_rdata structure.

 *   @param msg   - pointer to the dns message

 *   @param end   - pointer to the end of the record (rdata end)

 *   @param rdata - pointer  to the rdata part of the txt answer

 * returns 0 on error, or a dyn. alloc'ed txt_rdata structure */

/*  TXT rdata format:

 *

 * one or several character strings:

 *  01234567

 * +--------------------+

 * | len    | string   / ...

 * |------------------+

 */

static struct txt_rdata *dns_txt_parser(

    unsigned char *msg, unsigned char *end, unsigned char *rdata)

{

  struct txt_rdata *txt;

  int len, n, i;

  int str_size;

  unsigned char *p;

  unsigned char *st;

  txt = 0;

  if(unlikely((rdata + 1) > end))

    goto error;

  n = 0;

  str_size = 0;

  /* count the number of strings */

  p = rdata;

  do {

    len = *p;

    p += len + 1;

    str_size += len + 1; /* 1 for the term. 0 */

    if(unlikely(p > end))

      goto error;

    n++;

  } while(p < end);

  /* alloc sizeof struct + space for the dns_cstr array + space for

     the strings */

  txt = pkg_malloc(sizeof(struct txt_rdata)

           + (n - 1) * sizeof(struct dns_cstr) + str_size);

  if(unlikely(txt == 0)) {

    PKG_MEM_ERROR;

    goto error;

  }

  /* string table */

  st = (unsigned char *)txt + sizeof(struct txt_rdata)

     + (n - 1) * sizeof(struct dns_cstr);

  txt->cstr_no = n;

  txt->tslen = str_size;

  /* fill the structure */

  p = rdata;

  for(i = 0; i < n; i++) {

    len = *p;

    memcpy(st, p + 1, len);

    st[len] = 0;

    txt->txt[i].cstr_len = len;

    txt->txt[i].cstr = (char *)st;

    st += len + 1;

    p += len + 1;

  }

  return txt;

error:

  if(txt)

    pkg_free(txt);

  return 0;

}

/** parses an EBL record into a txt_rdata structure.

 *   @param msg   - pointer to the dns message

 *   @param end   - pointer to the end of the dns message

 *   @param eor   - pointer to the end of the record (rdata end)

 *   @param rdata - pointer  to the rdata part of the txt answer

 * returns 0 on error, or a dyn. alloc'ed txt_rdata structure */

/*  EBL rdata format:

 *  (see http://tools.ietf.org/html/draft-ietf-enum-branch-location-record-03)

 * one or several character strings:

 *  01234567

 * +---------+

 * | position|

 * +-----------+

 * / separator /

 * +-----------+

 * /   apex    /

 * +----------+

 *

 * where separator is a character string ( 8 bit len, followed by len chars)

 * and apex is a domain-name.

 */

static struct ebl_rdata *dns_ebl_parser(unsigned char *msg, unsigned char *end,

    unsigned char *eor, unsigned char *rdata)

{

  struct ebl_rdata *ebl;

  int sep_len;

  int apex_len;

  char apex[MAX_DNS_NAME];

  ebl = 0;

  /* check if len is at least 4 chars (minimum possible):

       pos (1 byte) +  sep. (min 1 byte) + apex (min. 2 bytes)

     and also check if rdata+1 (pos) + 1 (sep. len) + sep_len + 1 is ok*/

  if(unlikely(((rdata + 4) > eor) || ((rdata + 1 + 1 + rdata[1] + 2) > eor)))

    goto error;

  sep_len = rdata[1];

  if(unlikely(dn_expand(msg, end, rdata + 1 + 1 + sep_len, apex,

            MAX_DNS_NAME - 1)

        == -1))

    goto error;

  apex_len = strlen(apex);

  /* alloc sizeof struct + space for the 2 null-terminated strings */

  ebl = pkg_malloc(sizeof(struct ebl_rdata) - 1 + sep_len + 1 + apex_len + 1);

  if(ebl == 0) {

    PKG_MEM_ERROR;

    goto error;

  }

  ebl->position = rdata[0];

  ebl->separator = &ebl->str_table[0];

  ebl->apex = ebl->separator + sep_len + 1;

  ebl->separator_len = sep_len;

  ebl->apex_len = apex_len;

  memcpy(ebl->separator, rdata + 2, sep_len);

  ebl->separator[sep_len] = 0;

  memcpy(ebl->apex, apex, apex_len);

  ebl->apex[apex_len] = 0;

  return ebl;

error:

  if(ebl)

    pkg_free(ebl);

  return 0;

}

/** parses a PTR record into a ptr_rdata structure */

struct ptr_rdata *dns_ptr_parser(

    unsigned char *msg, unsigned char *end, unsigned char *rdata)

{

  struct ptr_rdata *pname;

  int len;

  char name[MAX_DNS_NAME];

  pname = 0;

  if(dn_expand(msg, end, rdata, name, MAX_DNS_NAME - 1) == -1)

    goto error;

  len = strlen(name);

  if(len > 255)

    goto error;

  /* alloc sizeof struct + space for the null terminated name */

  pname = pkg_malloc(sizeof(struct ptr_rdata) - 1 + len + 1);

  if(pname == 0) {

    PKG_MEM_ERROR;

    goto error;

  }

  pname->ptrdname_len = len;

  memcpy(pname->ptrdname, name, pname->ptrdname_len);

  pname->ptrdname[pname->ptrdname_len] = 0;

  return pname;

error:

  if(pname)

    pkg_free(pname);

  return 0;

}

/** frees completely a struct rdata list */

void free_rdata_list(struct rdata *head)

{

  struct rdata *l;

  struct rdata *next_l;

  l = head;

  while(l != 0) {

    next_l = l->next;

    /* free the parsed rdata*/

    if(l->rdata)

      pkg_free(l->rdata);

    pkg_free(l);

    l = next_l;

  }

}

#ifdef HAVE_RESOLV_RES

/** checks whether supplied name exists in the resolver search list

 * returns 1 if found

 *         0 if not found

 */

int match_search_list(const struct __res_state *res, char *name)

{

  int i;

  for(i = 0; (i < MAXDNSRCH) && (res->dnsrch[i]); i++) {

    if(strcasecmp(name, res->dnsrch[i]) == 0)

      return 1;

  }

  return 0;

}

#endif

#ifndef SR_DNS_MAX_QNO

#define SR_DNS_MAX_QNO 10

#endif

#ifndef SR_DNS_MAX_ANO

#define SR_DNS_MAX_ANO 100

#endif

/** gets the DNS records for name:type

 * returns a dyn. alloc'ed struct rdata linked list with the parsed responses

 * or 0 on error

 * see rfc1035 for the query/response format */

struct rdata *get_record(char *name, int type, int flags)

{

  int size;

  int skip;

  unsigned short qno, answers_no, r;

  int i;

  static union dns_query buff;

  unsigned char *p;

  unsigned char *end;

  unsigned char *rd_end;

  static char rec_name[MAX_DNS_NAME]; /* placeholder for the record name */

  int rec_name_len;

  unsigned short rtype, class, rdlength;

  unsigned int ttl;

  struct rdata *head;

  struct rdata **crt;

  struct rdata **last;

  struct rdata *rd;

  struct srv_rdata *srv_rd;

  struct srv_rdata *crt_srv;

  int search_list_used;

  int name_len;

  struct rdata *fullname_rd;

  char c;

  struct timeval start, stop;

  int slow_query_ms = cfg_get(core, core_cfg, dns_slow_query_ms);

  name_len = strlen(name);

  for(i = 0; i < name_len; i++) {

    c = name[i];

    if(((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))

        || ((c >= '0') && (c <= '9')) || (name[i] == '.')

        || (name[i] == '-') || (name[i] == '_'))

      continue;

    LM_DBG("'%s' is not domain name\n", name);

    return 0;

  }

  if(cfg_get(core, core_cfg, dns_search_list) == 0) {

    search_list_used = 0;

    name_len = 0;

  } else {

    search_list_used = 1;

  }

  fullname_rd = 0;

  if(slow_query_ms > 0)

    gettimeofday(&start, NULL);

  size = dns_func.sr_res_search(name, C_IN, type, buff.buff, sizeof(buff));

  if(slow_query_ms > 0) {

    gettimeofday(&stop, NULL);

    int latency_ms = (stop.tv_sec - start.tv_sec) * 1000

             + (stop.tv_usec - start.tv_usec) / 1000;

    if(slow_query_ms < latency_ms) {

      LOG(cfg_get(core, core_cfg, latency_log),

          "res_search[%d][%s]elapsed[%dms]\n", type, name,

          latency_ms);

      counter_inc(dns_cnts_h.slow_dns_req);

    }

  }

  if(unlikely(size < 0)) {

    LM_DBG("lookup(%s, %d) failed\n", name, type);

    goto not_found;

  } else if(unlikely(size > sizeof(buff)))

    size = sizeof(buff);

  head = rd = 0;

  last = crt = &head;

  p = buff.buff + DNS_HDR_SIZE;

  end = buff.buff + size;

  if(unlikely(p >= end))

    goto error_boundary;

  qno = ntohs((unsigned short)buff.hdr.qdcount);

  if(qno != 1) {

    /* usually the query is with a single domain name */

    LM_INFO("dns questions number is: %u\n", (uint32_t)qno);

    if(qno > SR_DNS_MAX_QNO) {

      /* early safe check against broken results */

      LM_ERR("dns questions number is too high: %u\n", (uint32_t)qno);

      goto error;

    }

  }

  for(r = 0; r < qno; r++) {

    /* skip the name of the question */

    if(unlikely((p = dns_skipname(p, end)) == 0)) {

      LM_ERR("skipname==0\n");

      goto error;

    }

    p += 2 + 2; /* skip QCODE & QCLASS */

#if 0

    for (;(p<end && (*p)); p++);

    p+=1+2+2; /* skip the ending  '\0, QCODE and QCLASS */

#endif

    if(unlikely(p > end)) {

      LM_ERR("p>=end\n");

      goto error;

    }

  }

  answers_no = ntohs((unsigned short)buff.hdr.ancount);

  if(answers_no > SR_DNS_MAX_ANO) {

    /* early safety check on answers number */

    LM_ERR("dns answers number is too high: %u\n", (uint32_t)answers_no);

    goto error;

  }

again:

  for(r = 0; (r < answers_no) && (p < end); r++) {

#if 0

    /*  ignore it the default domain name */

    if ((p=dns_skipname(p, end))==0) {

      LM_ERR("get_record: skip_name=0 (#2)\n");

      goto error;

    }

#else

    if(unlikely((skip = dn_expand(

               buff.buff, end, p, rec_name, MAX_DNS_NAME - 1))

          == -1)) {

      LM_ERR("dn_expand(rec_name) failed\n");

      goto error;

    }

#endif

    p += skip;

    rec_name_len = strlen(rec_name);

    if(unlikely(rec_name_len > MAX_DNS_NAME - 2)) {

      LM_ERR("dn_expand(rec_name): name too long (%d)\n", rec_name_len);

      goto error;

    }

    /* check if enough space is left for type, class, ttl & size */

    if(unlikely((p + 2 + 2 + 4 + 2) > end))

      goto error_boundary;

    /* get type */

    memcpy((void *)&rtype, (void *)p, 2);

    rtype = ntohs(rtype);

    p += 2;

    /* get  class */

    memcpy((void *)&class, (void *)p, 2);

    class = ntohs(class);

    p += 2;

    /* get ttl*/

    memcpy((void *)&ttl, (void *)p, 4);

    ttl = ntohl(ttl);

    p += 4;

    /* get size */

    memcpy((void *)&rdlength, (void *)p, 2);

    rdlength = ntohs(rdlength);

    p += 2;

    rd_end = p + rdlength;

    if(unlikely((rd_end) > end))

      goto error_boundary;

    if((flags & RES_ONLY_TYPE) && (rtype != type)) {

      /* skip */

      p = rd_end;

      continue;

    }

    /* expand the "type" record  (rdata)*/

    rd = (struct rdata *)pkg_malloc(

        sizeof(struct rdata) + rec_name_len + 1 - 1);

    if(rd == 0) {

      PKG_MEM_ERROR;

      goto error;

    }

    rd->type = rtype;

    rd->pclass = class;

    rd->ttl = ttl;

    rd->next = 0;

    memcpy(rd->name, rec_name, rec_name_len);

    rd->name[rec_name_len] = 0;

    rd->name_len = rec_name_len;