/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2010,2011  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT 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 3 of the License, or
 *  (at your option) any later version.
 *
 *  VAS_EBOOT 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 VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <VasEBoot/net.h>
#include <VasEBoot/net/udp.h>
#include <VasEBoot/command.h>
#include <VasEBoot/i18n.h>
#include <VasEBoot/err.h>
#include <VasEBoot/time.h>
#include <VasEBoot/safemath.h>

struct dns_cache_element
{
  char *name;
  VasEBoot_size_t naddresses;
  struct VasEBoot_net_network_level_address *addresses;
  VasEBoot_uint64_t limit_time;
};

#define DNS_CACHE_SIZE 1021
#define DNS_HASH_BASE 423

typedef enum VasEBoot_dns_qtype_id
  {
    VAS_EBOOT_DNS_QTYPE_A = 1,
    VAS_EBOOT_DNS_QTYPE_AAAA = 28
  } VasEBoot_dns_qtype_id_t;

static struct dns_cache_element dns_cache[DNS_CACHE_SIZE];
static struct VasEBoot_net_network_level_address *dns_servers;
static VasEBoot_size_t dns_nservers, dns_servers_alloc;

VasEBoot_err_t
VasEBoot_net_add_dns_server (const struct VasEBoot_net_network_level_address *s)
{
  if (dns_servers_alloc <= dns_nservers)
    {
      int na = dns_servers_alloc * 2;
      struct VasEBoot_net_network_level_address *ns;
      VasEBoot_size_t sz;

      if (na < 8)
	na = 8;

      if (VasEBoot_mul (na, sizeof (ns[0]), &sz))
	return VAS_EBOOT_ERR_OUT_OF_RANGE;

      ns = VasEBoot_realloc (dns_servers, sz);
      if (!ns)
	return VasEBoot_errno;
      dns_servers_alloc = na;
      dns_servers = ns;
    }
  dns_servers[dns_nservers++] = *s;
  return VAS_EBOOT_ERR_NONE;
}

void
VasEBoot_net_remove_dns_server (const struct VasEBoot_net_network_level_address *s)
{
  VasEBoot_size_t i;
  for (i = 0; i < dns_nservers; i++)
    if (VasEBoot_net_addr_cmp (s, &dns_servers[i]) == 0)
      break;
  if (i < dns_nservers)
    {
      dns_servers[i] = dns_servers[dns_nservers - 1];
      dns_nservers--;
    }
}

struct dns_header
{
  VasEBoot_uint16_t id;
  VasEBoot_uint8_t flags;
  VasEBoot_uint8_t ra_z_r_code;
  VasEBoot_uint16_t qdcount;
  VasEBoot_uint16_t ancount;
  VasEBoot_uint16_t nscount;
  VasEBoot_uint16_t arcount;
} VAS_EBOOT_PACKED;

enum
  {
    FLAGS_RESPONSE = 0x80,
    FLAGS_OPCODE = 0x78,
    FLAGS_RD = 0x01
  };

enum
  {
    ERRCODE_MASK = 0x0f
  };

enum
  {
    DNS_PORT = 53
  };

struct recv_data
{
  VasEBoot_size_t *naddresses;
  struct VasEBoot_net_network_level_address **addresses;
  int cache;
  VasEBoot_uint16_t id;
  int dns_err;
  char *name;
  const char *oname;
  int stop;
};

static inline int
hash (const char *str)
{
  unsigned v = 0, xn = 1;
  const char *ptr;
  for (ptr = str; *ptr; )
    {
      v = (v + xn * *ptr);
      xn = (DNS_HASH_BASE * xn) % DNS_CACHE_SIZE;
      ptr++;
      if (((ptr - str) & 0x3ff) == 0)
	v %= DNS_CACHE_SIZE;
    }
  return v % DNS_CACHE_SIZE;
}

static int
check_name_real (const VasEBoot_uint8_t *name_at, const VasEBoot_uint8_t *head,
		 const VasEBoot_uint8_t *tail, const char *check_with,
		 int *length, char *set)
{
  const char *readable_ptr = check_with;
  int readable_len;
  const VasEBoot_uint8_t *ptr;
  char *optr = set;
  int bytes_processed = 0;
  if (length)
    *length = 0;

  if (readable_ptr != NULL)
    readable_len = VasEBoot_strlen (readable_ptr);
  else
    readable_len = 0;

  for (ptr = name_at; ptr < tail && bytes_processed < tail - head + 2; )
    {
      /* End marker.  */
      if (!*ptr)
	{
	  if (length && *length)
	    (*length)--;
	  if (optr && optr != set)
	    optr--;
	  if (optr)
	    *optr = 0;
	  return !readable_ptr || (*readable_ptr == 0);
	}
      if (*ptr & 0xc0)
	{
	  bytes_processed += 2;
	  if (ptr + 1 >= tail)
	    return 0;
	  ptr = head + (((ptr[0] & 0x3f) << 8) | ptr[1]);
	  continue;
	}
      if (readable_ptr != NULL && (*ptr > readable_len || VasEBoot_memcmp (ptr + 1, readable_ptr, *ptr) != 0))
	return 0;
      if (VasEBoot_memchr (ptr + 1, 0, *ptr)
	  || VasEBoot_memchr (ptr + 1, '.', *ptr))
	return 0;
      if (readable_ptr)
	{
	  readable_ptr += *ptr;
	  readable_len -= *ptr;
	}
      if (readable_ptr && *readable_ptr != '.' && *readable_ptr != 0)
	return 0;
      bytes_processed += *ptr + 1;
      if (length)
	*length += *ptr + 1;
      if (optr)
	{
	  VasEBoot_memcpy (optr, ptr + 1, *ptr);
	  optr += *ptr;
	}
      if (optr)
	*optr++ = '.';
      if (readable_ptr && *readable_ptr)
	{
	  readable_ptr++;
	  readable_len--;
	}
      ptr += *ptr + 1;
    }
  return 0;
}

static int
check_name (const VasEBoot_uint8_t *name_at, const VasEBoot_uint8_t *head,
	    const VasEBoot_uint8_t *tail, const char *check_with)
{
  return check_name_real (name_at, head, tail, check_with, NULL, NULL);
}

static char *
get_name (const VasEBoot_uint8_t *name_at, const VasEBoot_uint8_t *head,
	  const VasEBoot_uint8_t *tail)
{
  int length;
  char *ret;
  int len;

  if (!check_name_real (name_at, head, tail, NULL, &length, NULL))
    return NULL;

  if (VasEBoot_add (length, 1, &len))
    {
      VasEBoot_error (VAS_EBOOT_ERR_OUT_OF_RANGE, N_("name length overflow"));
      return NULL;
    }
  ret = VasEBoot_malloc (len);
  if (!ret)
    return NULL;
  if (!check_name_real (name_at, head, tail, NULL, NULL, ret))
    {
      VasEBoot_free (ret);
      return NULL;
    }
  return ret;
}

enum
  {
    DNS_CLASS_A = 1,
    DNS_CLASS_CNAME = 5,
    DNS_CLASS_AAAA = 28
  };

static VasEBoot_err_t
recv_hook (VasEBoot_net_udp_socket_t sock __attribute__ ((unused)),
	   struct VasEBoot_net_buff *nb,
	   void *data_)
{
  struct dns_header *head;
  struct recv_data *data = data_;
  int i, j;
  VasEBoot_uint8_t *ptr, *reparse_ptr;
  int redirect_cnt = 0;
  char *redirect_save = NULL;
  VasEBoot_uint32_t ttl_all = ~0U;

  /* Code apparently assumed that only one packet is received as response.
     We may get multiple responses due to network condition, so check here
     and quit early. */
  if (*data->naddresses)
    goto out;

  head = (struct dns_header *) nb->data;
  ptr = (VasEBoot_uint8_t *) (head + 1);
  if (ptr >= nb->tail)
    goto out;

  if (head->id != data->id)
    goto out;
  if (!(head->flags & FLAGS_RESPONSE) || (head->flags & FLAGS_OPCODE))
    goto out;
  if (head->ra_z_r_code & ERRCODE_MASK)
    {
      data->dns_err = 1;
      goto out;
    }
  for (i = 0; i < VasEBoot_be_to_cpu16 (head->qdcount); i++)
    {
      if (ptr >= nb->tail)
	goto out;
      while (ptr < nb->tail && !((*ptr & 0xc0) || *ptr == 0))
	ptr += *ptr + 1;
      if (ptr < nb->tail && (*ptr & 0xc0))
	ptr++;
      ptr++;
      ptr += 4;
    }
  *data->addresses = VasEBoot_calloc (VasEBoot_be_to_cpu16 (head->ancount),
				  sizeof ((*data->addresses)[0]));
  if (!*data->addresses)
    {
      VasEBoot_errno = VAS_EBOOT_ERR_NONE;
      goto out;
    }
  reparse_ptr = ptr;
 reparse:
  for (i = 0, ptr = reparse_ptr; i < VasEBoot_be_to_cpu16 (head->ancount); i++)
    {
      int ignored = 0;
      VasEBoot_uint8_t class;
      VasEBoot_uint32_t ttl = 0;
      VasEBoot_uint16_t length;
      if (ptr >= nb->tail)
	goto out;
      ignored = !check_name (ptr, nb->data, nb->tail, data->name);
      while (ptr < nb->tail && !((*ptr & 0xc0) || *ptr == 0))
	ptr += *ptr + 1;
      if (ptr < nb->tail && (*ptr & 0xc0))
	ptr++;
      ptr++;
      if (ptr + 10 >= nb->tail)
	goto out;
      if (*ptr++ != 0)
	ignored = 1;
      class = *ptr++;
      if (*ptr++ != 0)
	ignored = 1;
      if (*ptr++ != 1)
	ignored = 1;
      for (j = 0; j < 4; j++)
	{
	  ttl <<= 8;
	  ttl |= *ptr++;
	}
      length = *ptr++ << 8;
      length |= *ptr++;
      if (ptr + length > nb->tail)
	goto out;
      if (!ignored)
	{
	  if (ttl_all > ttl)
	    ttl_all = ttl;
	  switch (class)
	    {
	    case DNS_CLASS_A:
	      if (length != 4)
		break;
	      (*data->addresses)[*data->naddresses].type
		= VAS_EBOOT_NET_NETWORK_LEVEL_PROTOCOL_IPV4;
	      VasEBoot_memcpy (&(*data->addresses)[*data->naddresses].ipv4,
			   ptr, 4);
	      VasEBoot_dprintf ("dns", "got A 0x%x\n", (*data->addresses)[*data->naddresses].ipv4);
	      (*data->naddresses)++;
	      data->stop = 1;
	      break;
	    case DNS_CLASS_AAAA:
	      if (length != 16)
		break;
	      (*data->addresses)[*data->naddresses].type
		= VAS_EBOOT_NET_NETWORK_LEVEL_PROTOCOL_IPV6;
	      VasEBoot_memcpy (&(*data->addresses)[*data->naddresses].ipv6,
			   ptr, 16);
	      VasEBoot_dprintf ("dns", "got AAAA 0x%" PRIxVAS_EBOOT_UINT64_T "%" PRIxVAS_EBOOT_UINT64_T "\n",
			    (*data->addresses)[*data->naddresses].ipv6[0],
			    (*data->addresses)[*data->naddresses].ipv6[1]);
	      (*data->naddresses)++;
	      data->stop = 1;
	      break;
	    case DNS_CLASS_CNAME:
	      if (!(redirect_cnt & (redirect_cnt - 1)))
		{
		  VasEBoot_free (redirect_save);
		  redirect_save = data->name;
		}
	      else
		VasEBoot_free (data->name);
	      redirect_cnt++;
	      data->name = get_name (ptr, nb->data, nb->tail);
	      if (!data->name)
		{
		  data->dns_err = 1;
		  VasEBoot_errno = VAS_EBOOT_ERR_NONE;
		  goto out;
		}
	      VasEBoot_dprintf ("dns", "CNAME %s\n", data->name);
	      if (VasEBoot_strcmp (redirect_save, data->name) == 0)
		{
		  data->dns_err = 1;
		  goto out;
		}
	      goto reparse;
	    }
	}
      ptr += length;
    }
  if (ttl_all && *data->naddresses && data->cache)
    {
      int h;
      VasEBoot_dprintf ("dns", "caching for %d seconds\n", ttl_all);
      h = hash (data->oname);
      VasEBoot_free (dns_cache[h].name);
      dns_cache[h].name = 0;
      VasEBoot_free (dns_cache[h].addresses);
      dns_cache[h].addresses = 0;
      dns_cache[h].name = VasEBoot_strdup (data->oname);
      dns_cache[h].naddresses = *data->naddresses;
      dns_cache[h].addresses = VasEBoot_calloc (*data->naddresses,
					    sizeof (dns_cache[h].addresses[0]));
      dns_cache[h].limit_time = VasEBoot_get_time_ms () + 1000 * ttl_all;
      if (!dns_cache[h].addresses || !dns_cache[h].name)
	{
	  VasEBoot_free (dns_cache[h].name);
	  dns_cache[h].name = 0;
	  VasEBoot_free (dns_cache[h].addresses);
	  dns_cache[h].addresses = 0;
	}
      VasEBoot_memcpy (dns_cache[h].addresses, *data->addresses,
		   *data->naddresses
		   * sizeof (dns_cache[h].addresses[0]));
    }

 out:
  VasEBoot_netbuff_free (nb);
  VasEBoot_free (redirect_save);
  if (!*data->naddresses)
    {
      VasEBoot_free (*data->addresses);
      *data->addresses = NULL;
    }
  return VAS_EBOOT_ERR_NONE;
}

VasEBoot_err_t
VasEBoot_net_dns_lookup (const char *name,
		     const struct VasEBoot_net_network_level_address *servers,
		     VasEBoot_size_t n_servers,
		     VasEBoot_size_t *naddresses,
		     struct VasEBoot_net_network_level_address **addresses,
		     int cache)
{
  VasEBoot_size_t send_servers = 0;
  VasEBoot_size_t i, j;
  struct VasEBoot_net_buff *nb;
  VasEBoot_net_udp_socket_t *sockets;
  VasEBoot_uint8_t *optr;
  const char *iptr;
  struct dns_header *head;
  static VasEBoot_uint16_t id = 1;
  VasEBoot_uint8_t *qtypeptr;
  VasEBoot_err_t err = VAS_EBOOT_ERR_NONE;
  struct recv_data data = {naddresses, addresses, cache,
			   VasEBoot_cpu_to_be16 (id++), 0, 0, name, 0};
  VasEBoot_uint8_t *nbd;
  VasEBoot_size_t try_server = 0;

  if (!servers)
    {
      servers = dns_servers;
      n_servers = dns_nservers;
    }

  if (!n_servers)
    return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
		       N_("no DNS servers configured"));

  *naddresses = 0;
  if (cache)
    {
      int h;
      h = hash (name);
      if (dns_cache[h].name && VasEBoot_strcmp (dns_cache[h].name, name) == 0
	  && VasEBoot_get_time_ms () < dns_cache[h].limit_time)
	{
	  VasEBoot_dprintf ("dns", "retrieved from cache\n");
	  *addresses = VasEBoot_calloc (dns_cache[h].naddresses,
				    sizeof ((*addresses)[0]));
	  if (!*addresses)
	    return VasEBoot_errno;
	  *naddresses = dns_cache[h].naddresses;
	  VasEBoot_memcpy (*addresses, dns_cache[h].addresses,
		       dns_cache[h].naddresses
		       * sizeof ((*addresses)[0]));
	  return VAS_EBOOT_ERR_NONE;
	}
    }

  sockets = VasEBoot_calloc (n_servers, sizeof (sockets[0]));
  if (!sockets)
    return VasEBoot_errno;

  data.name = VasEBoot_strdup (name);
  if (!data.name)
    {
      VasEBoot_free (sockets);
      return VasEBoot_errno;
    }

  nb = VasEBoot_netbuff_alloc (VAS_EBOOT_NET_OUR_MAX_IP_HEADER_SIZE
			   + VAS_EBOOT_NET_MAX_LINK_HEADER_SIZE
			   + VAS_EBOOT_NET_UDP_HEADER_SIZE
			   + sizeof (struct dns_header)
			   + VasEBoot_strlen (name) + 2 + 4);
  if (!nb)
    {
      VasEBoot_free (sockets);
      VasEBoot_free (data.name);
      return VasEBoot_errno;
    }
  VasEBoot_netbuff_reserve (nb, VAS_EBOOT_NET_OUR_MAX_IP_HEADER_SIZE
			+ VAS_EBOOT_NET_MAX_LINK_HEADER_SIZE
			+ VAS_EBOOT_NET_UDP_HEADER_SIZE);
  VasEBoot_netbuff_put (nb, sizeof (struct dns_header)
		    + VasEBoot_strlen (name) + 2 + 4);
  head = (struct dns_header *) nb->data;
  optr = (VasEBoot_uint8_t *) (head + 1);
  for (iptr = name; *iptr; )
    {
      const char *dot;
      dot = VasEBoot_strchr (iptr, '.');
      if (!dot)
	dot = iptr + VasEBoot_strlen (iptr);
      if ((dot - iptr) >= 64)
	{
	  VasEBoot_free (sockets);
	  VasEBoot_free (data.name);
	  return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT,
			     N_("domain name component is too long"));
	}
      *optr = (dot - iptr);
      optr++;
      VasEBoot_memcpy (optr, iptr, dot - iptr);
      optr += dot - iptr;
      iptr = dot;
      if (*iptr)
	iptr++;
    }
  *optr++ = 0;

  /* Type.  */
  *optr++ = 0;
  qtypeptr = optr++;

  /* Class.  */
  *optr++ = 0;
  *optr++ = 1;

  head->id = data.id;
  head->flags = FLAGS_RD;
  head->ra_z_r_code = 0;
  head->qdcount = VasEBoot_cpu_to_be16_compile_time (1);
  head->ancount = VasEBoot_cpu_to_be16_compile_time (0);
  head->nscount = VasEBoot_cpu_to_be16_compile_time (0);
  head->arcount = VasEBoot_cpu_to_be16_compile_time (0);

  nbd = nb->data;

  for (i = 0; i < n_servers * 4; i++)
    {
      /* Connect to a next server.  */
      while (!(i & 1) && try_server < n_servers)
	{
	  sockets[send_servers] = VasEBoot_net_udp_open (servers[try_server++],
						     DNS_PORT,
						     recv_hook,
						     &data);
	  if (!sockets[send_servers])
	    {
	      err = VasEBoot_errno;
	      VasEBoot_errno = VAS_EBOOT_ERR_NONE;
	    }
	  else
	    {
	      send_servers++;
	      break;
	    }
	}
      if (!send_servers)
	goto out;
      if (*data.naddresses)
	goto out;
      for (j = 0; j < send_servers; j++)
	{
          VasEBoot_err_t err2;

          VasEBoot_size_t t = 0;
          do
            {
              nb->data = nbd;
              if (servers[j].option == DNS_OPTION_IPV4 ||
                 ((servers[j].option == DNS_OPTION_PREFER_IPV4) && (t++ == 0)) ||
                 ((servers[j].option == DNS_OPTION_PREFER_IPV6) && (t++ == 1)))
                *qtypeptr = VAS_EBOOT_DNS_QTYPE_A;
              else
                *qtypeptr = VAS_EBOOT_DNS_QTYPE_AAAA;

              VasEBoot_dprintf ("dns", "QTYPE: %u QNAME: %s\n", *qtypeptr, name);

              err2 = VasEBoot_net_send_udp_packet (sockets[j], nb);
              if (err2)
                {
                  VasEBoot_errno = VAS_EBOOT_ERR_NONE;
                  err = err2;
                }
              if (*data.naddresses)
                goto out;
            }
          while (t == 1);
	}
      VasEBoot_net_poll_cards (200, &data.stop);
    }
 out:
  VasEBoot_free (data.name);
  VasEBoot_netbuff_free (nb);
  for (j = 0; j < send_servers; j++)
    VasEBoot_net_udp_close (sockets[j]);

  VasEBoot_free (sockets);

  if (*data.naddresses)
    return VAS_EBOOT_ERR_NONE;
  if (data.dns_err)
    return VasEBoot_error (VAS_EBOOT_ERR_NET_NO_DOMAIN,
		       N_("no DNS record found"));

  if (err)
    {
      VasEBoot_errno = err;
      return err;
    }
  return VasEBoot_error (VAS_EBOOT_ERR_TIMEOUT,
		     N_("no DNS reply received"));
}

static VasEBoot_err_t
VasEBoot_cmd_nslookup (struct VasEBoot_command *cmd __attribute__ ((unused)),
		   int argc, char **args)
{
  VasEBoot_err_t err;
  struct VasEBoot_net_network_level_address cmd_server;
  struct VasEBoot_net_network_level_address *servers;
  VasEBoot_size_t nservers, i, naddresses = 0;
  struct VasEBoot_net_network_level_address *addresses = 0;
  if (argc != 2 && argc != 1)
    return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("two arguments expected"));
  if (argc == 2)
    {
      err = VasEBoot_net_resolve_address (args[1], &cmd_server);
      if (err)
	return err;
      servers = &cmd_server;
      nservers = 1;
    }
  else
    {
      servers = dns_servers;
      nservers = dns_nservers;
    }

  VasEBoot_net_dns_lookup (args[0], servers, nservers, &naddresses,
                       &addresses, 0);

  for (i = 0; i < naddresses; i++)
    {
      char buf[VAS_EBOOT_NET_MAX_STR_ADDR_LEN];
      VasEBoot_net_addr_to_str (&addresses[i], buf);
      VasEBoot_printf ("%s\n", buf);
    }
  if (naddresses)
    {
      VasEBoot_free (addresses);
      return VAS_EBOOT_ERR_NONE;
    }
  return VasEBoot_error (VAS_EBOOT_ERR_NET_NO_DOMAIN, N_("no DNS record found"));
}

static VasEBoot_err_t
VasEBoot_cmd_list_dns (struct VasEBoot_command *cmd __attribute__ ((unused)),
		   int argc __attribute__ ((unused)),
		   char **args __attribute__ ((unused)))
{
  VasEBoot_size_t i;
  const char *strtype = "";

  for (i = 0; i < dns_nservers; i++)
    {
      switch (dns_servers[i].option)
        {
        case DNS_OPTION_IPV4:
          strtype = _("only ipv4");
          break;

        case DNS_OPTION_IPV6:
          strtype = _("only ipv6");
          break;

        case DNS_OPTION_PREFER_IPV4:
          strtype = _("prefer ipv4");
          break;

        case DNS_OPTION_PREFER_IPV6:
          strtype = _("prefer ipv6");
          break;
        }

      char buf[VAS_EBOOT_NET_MAX_STR_ADDR_LEN];
      VasEBoot_net_addr_to_str (&dns_servers[i], buf);
      VasEBoot_printf ("%s (%s)\n", buf, strtype);
    }
  return VAS_EBOOT_ERR_NONE;
}

static VasEBoot_err_t
VasEBoot_cmd_add_dns (struct VasEBoot_command *cmd __attribute__ ((unused)),
		  int argc, char **args)
{
  VasEBoot_err_t err;
  struct VasEBoot_net_network_level_address server;

  if ((argc < 1) || (argc > 2))
    return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("one argument expected"));
  else if (argc == 1)
    server.option = DNS_OPTION_PREFER_IPV4;
  else
    {
      if (VasEBoot_strcmp (args[1], "--only-ipv4") == 0)
          server.option = DNS_OPTION_IPV4;
      else if (VasEBoot_strcmp (args[1], "--only-ipv6") == 0)
          server.option = DNS_OPTION_IPV6;
      else if (VasEBoot_strcmp (args[1], "--prefer-ipv4") == 0)
          server.option = DNS_OPTION_PREFER_IPV4;
      else if (VasEBoot_strcmp (args[1], "--prefer-ipv6") == 0)
          server.option = DNS_OPTION_PREFER_IPV6;
      else
        return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("invalid argument"));
    }

  err = VasEBoot_net_resolve_address (args[0], &server);
  if (err)
    return err;

  return VasEBoot_net_add_dns_server (&server);
}

static VasEBoot_err_t
VasEBoot_cmd_del_dns (struct VasEBoot_command *cmd __attribute__ ((unused)),
		  int argc, char **args)
{
  VasEBoot_err_t err;
  struct VasEBoot_net_network_level_address server;

  if (argc != 1)
    return VasEBoot_error (VAS_EBOOT_ERR_BAD_ARGUMENT, N_("one argument expected"));

  err = VasEBoot_net_resolve_address (args[0], &server);
  if (err)
    return err;

  VasEBoot_net_remove_dns_server (&server);

  return VAS_EBOOT_ERR_NONE;
}

static VasEBoot_command_t cmd, cmd_add, cmd_del, cmd_list;

void
VasEBoot_dns_init (void)
{
  cmd = VasEBoot_register_command ("net_nslookup", VasEBoot_cmd_nslookup,
			       N_("ADDRESS DNSSERVER"),
			       N_("Perform a DNS lookup"));
  cmd_add = VasEBoot_register_command ("net_add_dns", VasEBoot_cmd_add_dns,
				   N_("DNSSERVER"),
				   N_("Add a DNS server"));
  cmd_del = VasEBoot_register_command ("net_del_dns", VasEBoot_cmd_del_dns,
				   N_("DNSSERVER"),
				   N_("Remove a DNS server"));
  cmd_list = VasEBoot_register_command ("net_ls_dns", VasEBoot_cmd_list_dns,
				   NULL, N_("List DNS servers"));
}

void
VasEBoot_dns_fini (void)
{
  VasEBoot_unregister_command (cmd);
  VasEBoot_unregister_command (cmd_add);
  VasEBoot_unregister_command (cmd_del);
  VasEBoot_unregister_command (cmd_list);
}