arch/all-pc/boot/grub2-aros/grub-core/net/dns.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2010,2011  Free Software Foundation, Inc.
   4  *
   5  *  GRUB is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <grub/net.h>
  20 #include <grub/net/udp.h>
  21 #include <grub/command.h>
  22 #include <grub/i18n.h>
  23 #include <grub/err.h>
  24 #include <grub/time.h>
  25
  26 struct dns_cache_element
  27 {
  28   char *name;
  29   grub_size_t naddresses;
  30   struct grub_net_network_level_address *addresses;
  31   grub_uint64_t limit_time;
  32 };
  33
  34 #define DNS_CACHE_SIZE 1021
  35 #define DNS_HASH_BASE 423
  36
  37 static struct dns_cache_element dns_cache[DNS_CACHE_SIZE];
  38 static struct grub_net_network_level_address *dns_servers;
  39 static grub_size_t dns_nservers, dns_servers_alloc;
  40
  41 grub_err_t
  42 grub_net_add_dns_server (const struct grub_net_network_level_address *s)
  43 {
  44   if (dns_servers_alloc <= dns_nservers)
  45     {
  46       int na = dns_servers_alloc * 2;
  47       struct grub_net_network_level_address *ns;
  48       if (na < 8)
  49         na = 8;
  50       ns = grub_realloc (dns_servers, na * sizeof (ns[0]));
  51       if (!ns)
  52         return grub_errno;
  53       dns_servers_alloc = na;
  54       dns_servers = ns;
  55     }
  56   dns_servers[dns_nservers++] = *s;
  57   return GRUB_ERR_NONE;
  58 }
  59
  60 void
  61 grub_net_remove_dns_server (const struct grub_net_network_level_address *s)
  62 {
  63   grub_size_t i;
  64   for (i = 0; i < dns_nservers; i++)
  65     if (grub_net_addr_cmp (s, &dns_servers[i]) == 0)
  66       break;
  67   if (i < dns_nservers)
  68     {
  69       dns_servers[i] = dns_servers[dns_nservers - 1];
  70       dns_nservers--;
  71     }
  72 }
  73
  74 struct dns_header
  75 {
  76   grub_uint16_t id;
  77   grub_uint8_t flags;
  78   grub_uint8_t ra_z_r_code;
  79   grub_uint16_t qdcount;
  80   grub_uint16_t ancount;
  81   grub_uint16_t nscount;
  82   grub_uint16_t arcount;
  83 } __attribute__ ((packed));
  84
  85 enum
  86   {
  87     FLAGS_RESPONSE = 0x80,
  88     FLAGS_OPCODE = 0x78,
  89     FLAGS_RD = 0x01
  90   };
  91
  92 enum
  93   {
  94     ERRCODE_MASK = 0x0f
  95   };
  96
  97 enum
  98   {
  99     DNS_PORT = 53
 100   };
 101
 102 struct recv_data
 103 {
 104   grub_size_t *naddresses;
 105   struct grub_net_network_level_address **addresses;
 106   int cache;
 107   grub_uint16_t id;
 108   int dns_err;
 109   char *name;
 110   const char *oname;
 111   int stop;
 112 };
 113
 114 static inline int
 115 hash (const char *str)
 116 {
 117   int v = 0, xn = 1;
 118   const char *ptr;
 119   for (ptr = str; *ptr; )
 120     {
 121       v = (v + xn * *ptr);
 122       xn = (DNS_HASH_BASE * xn) % DNS_CACHE_SIZE;
 123       ptr++;
 124       if (((ptr - str) & 0x3ff) == 0)
 125         v %= DNS_CACHE_SIZE;
 126     }
 127   return v % DNS_CACHE_SIZE;
 128 }
 129
 130 static int
 131 check_name_real (const grub_uint8_t *name_at, const grub_uint8_t *head,
 132                  const grub_uint8_t *tail, const char *check_with,
 133                  int *length, char *set)
 134 {
 135   const char *readable_ptr = check_with;
 136   const grub_uint8_t *ptr;
 137   char *optr = set;
 138   int bytes_processed = 0;
 139   if (length)
 140     *length = 0;
 141   for (ptr = name_at; ptr < tail && bytes_processed < tail - head + 2; )
 142     {
 143       /* End marker.  */
 144       if (!*ptr)
 145         {
 146           if (length && *length)
 147             (*length)--;
 148           if (optr && optr != set)
 149             optr--;
 150           if (optr)
 151             *optr = 0;
 152           return !readable_ptr || (*readable_ptr == 0);
 153         }
 154       if (*ptr & 0xc0)
 155         {
 156           bytes_processed += 2;
 157           if (ptr + 1 >= tail)
 158             return 0;
 159           ptr = head + (((ptr[0] & 0x3f) << 8) | ptr[1]);
 160           continue;
 161         }
 162       if (readable_ptr && grub_memcmp (ptr + 1, readable_ptr, *ptr) != 0)
 163         return 0;
 164       if (grub_memchr (ptr + 1, 0, *ptr)
 165           || grub_memchr (ptr + 1, '.', *ptr))
 166         return 0;
 167       if (readable_ptr)
 168         readable_ptr += *ptr;
 169       if (readable_ptr && *readable_ptr != '.' && *readable_ptr != 0)
 170         return 0;
 171       bytes_processed += *ptr + 1;
 172       if (length)
 173         *length += *ptr + 1;
 174       if (optr)
 175         {
 176           grub_memcpy (optr, ptr + 1, *ptr);
 177           optr += *ptr;
 178         }
 179       if (optr)
 180         *optr++ = '.';
 181       if (readable_ptr && *readable_ptr)
 182         readable_ptr++;
 183       ptr += *ptr + 1;
 184     }
 185   return 0;
 186 }
 187
 188 static int
 189 check_name (const grub_uint8_t *name_at, const grub_uint8_t *head,
 190             const grub_uint8_t *tail, const char *check_with)
 191 {
 192   return check_name_real (name_at, head, tail, check_with, NULL, NULL);
 193 }
 194
 195 static char *
 196 get_name (const grub_uint8_t *name_at, const grub_uint8_t *head,
 197           const grub_uint8_t *tail)
 198 {
 199   int length;
 200   char *ret;
 201
 202   if (!check_name_real (name_at, head, tail, NULL, &length, NULL))
 203     return NULL;
 204   ret = grub_malloc (length + 1);
 205   if (!ret)
 206     return NULL;
 207   if (!check_name_real (name_at, head, tail, NULL, NULL, ret))
 208     {
 209       grub_free (ret);
 210       return NULL;
 211     }
 212   return ret;
 213 }
 214
 215 enum
 216   {
 217     DNS_CLASS_A = 1,
 218     DNS_CLASS_CNAME = 5,
 219     DNS_CLASS_AAAA = 28
 220   };
 221
 222 static grub_err_t
 223 recv_hook (grub_net_udp_socket_t sock __attribute__ ((unused)),
 224            struct grub_net_buff *nb,
 225            void *data_)
 226 {
 227   struct dns_header *head;
 228   struct recv_data *data = data_;
 229   int i, j;
 230   grub_uint8_t *ptr, *reparse_ptr;
 231   int redirect_cnt = 0;
 232   char *redirect_save = NULL;
 233   grub_uint32_t ttl_all = ~0U;
 234
 235   head = (struct dns_header *) nb->data;
 236   ptr = (grub_uint8_t *) (head + 1);
 237   if (ptr >= nb->tail)
 238     {
 239       grub_netbuff_free (nb);
 240       return GRUB_ERR_NONE;
 241     }
 242
 243   if (head->id != data->id)
 244     {
 245       grub_netbuff_free (nb);
 246       return GRUB_ERR_NONE;
 247     }
 248   if (!(head->flags & FLAGS_RESPONSE) || (head->flags & FLAGS_OPCODE))
 249     {
 250       grub_netbuff_free (nb);
 251       return GRUB_ERR_NONE;
 252     }
 253   if (head->ra_z_r_code & ERRCODE_MASK)
 254     {
 255       data->dns_err = 1;
 256       grub_netbuff_free (nb);
 257       return GRUB_ERR_NONE;
 258     }
 259   for (i = 0; i < grub_cpu_to_be16 (head->qdcount); i++)
 260     {
 261       if (ptr >= nb->tail)
 262         {
 263           grub_netbuff_free (nb);
 264           return GRUB_ERR_NONE;
 265         }
 266       while (ptr < nb->tail && !((*ptr & 0xc0) || *ptr == 0))
 267         ptr += *ptr + 1;
 268       if (ptr < nb->tail && (*ptr & 0xc0))
 269         ptr++;
 270       ptr++;
 271       ptr += 4;
 272     }
 273   *data->addresses = grub_malloc (sizeof ((*data->addresses)[0])
 274                                  * grub_cpu_to_be16 (head->ancount));
 275   if (!*data->addresses)
 276     {
 277       grub_errno = GRUB_ERR_NONE;
 278       grub_netbuff_free (nb);
 279       return GRUB_ERR_NONE;
 280     }
 281   reparse_ptr = ptr;
 282  reparse:
 283   for (i = 0, ptr = reparse_ptr; i < grub_cpu_to_be16 (head->ancount); i++)
 284     {
 285       int ignored = 0;
 286       grub_uint8_t class;
 287       grub_uint32_t ttl = 0;
 288       grub_uint16_t length;
 289       if (ptr >= nb->tail)
 290         {
 291           if (!*data->naddresses)
 292             grub_free (*data->addresses);
 293           return GRUB_ERR_NONE;
 294         }
 295       ignored = !check_name (ptr, nb->data, nb->tail, data->name);
 296       while (ptr < nb->tail && !((*ptr & 0xc0) || *ptr == 0))
 297         ptr += *ptr + 1;
 298       if (ptr < nb->tail && (*ptr & 0xc0))
 299         ptr++;
 300       ptr++;
 301       if (ptr + 10 >= nb->tail)
 302         {
 303           if (!*data->naddresses)
 304             grub_free (*data->addresses);
 305           grub_netbuff_free (nb);
 306           return GRUB_ERR_NONE;
 307         }
 308       if (*ptr++ != 0)
 309         ignored = 1;
 310       class = *ptr++;
 311       if (*ptr++ != 0)
 312         ignored = 1;
 313       if (*ptr++ != 1)
 314         ignored = 1;
 315       for (j = 0; j < 4; j++)
 316         {
 317           ttl <<= 8;
 318           ttl |= *ptr++;
 319         }
 320       length = *ptr++ << 8;
 321       length |= *ptr++;
 322       if (ptr + length > nb->tail)
 323         {
 324           if (!*data->naddresses)
 325             grub_free (*data->addresses);
 326           grub_netbuff_free (nb);
 327           return GRUB_ERR_NONE;
 328         }
 329       if (!ignored)
 330         {
 331           if (ttl_all > ttl)
 332             ttl_all = ttl;
 333           switch (class)
 334             {
 335             case DNS_CLASS_A:
 336               if (length != 4)
 337                 break;
 338               (*data->addresses)[*data->naddresses].type
 339                 = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4;
 340               grub_memcpy (&(*data->addresses)[*data->naddresses].ipv4,
 341                            ptr, 4);
 342               (*data->naddresses)++;
 343               data->stop = 1;
 344               break;
 345             case DNS_CLASS_AAAA:
 346               if (length != 16)
 347                 break;
 348               (*data->addresses)[*data->naddresses].type
 349                 = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6;
 350               grub_memcpy (&(*data->addresses)[*data->naddresses].ipv6,
 351                            ptr, 16);
 352               (*data->naddresses)++;
 353               data->stop = 1;
 354               break;
 355             case DNS_CLASS_CNAME:
 356               if (!(redirect_cnt & (redirect_cnt - 1)))
 357                 {
 358                   grub_free (redirect_save);
 359                   redirect_save = data->name;
 360                 }
 361               else
 362                 grub_free (data->name);
 363               redirect_cnt++;
 364               data->name = get_name (ptr, nb->data, nb->tail);
 365               if (!data->name)
 366                 {
 367                   data->dns_err = 1;
 368                   grub_errno = 0;
 369                   return GRUB_ERR_NONE;
 370                 }
 371               grub_dprintf ("dns", "CNAME %s\n", data->name);
 372               if (grub_strcmp (redirect_save, data->name) == 0)
 373                 {
 374                   data->dns_err = 1;
 375                   grub_free (redirect_save);
 376                   return GRUB_ERR_NONE;
 377                 }
 378               goto reparse;
 379             }
 380         }
 381       ptr += length;
 382     }
 383   if (ttl_all && *data->naddresses && data->cache)
 384     {
 385       int h;
 386       grub_dprintf ("dns", "caching for %d seconds\n", ttl_all);
 387       h = hash (data->oname);
 388       grub_free (dns_cache[h].name);
 389       dns_cache[h].name = 0;
 390       grub_free (dns_cache[h].addresses);
 391       dns_cache[h].addresses = 0;
 392       dns_cache[h].name = grub_strdup (data->oname);
 393       dns_cache[h].naddresses = *data->naddresses;
 394       dns_cache[h].addresses = grub_malloc (*data->naddresses
 395                                             * sizeof (dns_cache[h].addresses[0]));
 396       dns_cache[h].limit_time = grub_get_time_ms () + 1000 * ttl_all;
 397       if (!dns_cache[h].addresses || !dns_cache[h].name)
 398         {
 399           grub_free (dns_cache[h].name);
 400           dns_cache[h].name = 0;
 401           grub_free (dns_cache[h].addresses);
 402           dns_cache[h].addresses = 0;
 403         }
 404       grub_memcpy (dns_cache[h].addresses, *data->addresses,
 405                    *data->naddresses
 406                    * sizeof (dns_cache[h].addresses[0]));
 407     }
 408   grub_netbuff_free (nb);
 409   grub_free (redirect_save);
 410   return GRUB_ERR_NONE;
 411 }
 412
 413 grub_err_t
 414 grub_net_dns_lookup (const char *name,
 415                      const struct grub_net_network_level_address *servers,
 416                      grub_size_t n_servers,
 417                      grub_size_t *naddresses,
 418                      struct grub_net_network_level_address **addresses,
 419                      int cache)
 420 {
 421   grub_size_t send_servers = 0;
 422   grub_size_t i, j;
 423   struct grub_net_buff *nb;
 424   grub_net_udp_socket_t sockets[n_servers];
 425   grub_uint8_t *optr;
 426   const char *iptr;
 427   struct dns_header *head;
 428   static grub_uint16_t id = 1;
 429   grub_err_t err = GRUB_ERR_NONE;
 430   struct recv_data data = {naddresses, addresses, cache,
 431                            grub_cpu_to_be16 (id++), 0, 0, name, 0};
 432   grub_uint8_t *nbd;
 433   int have_server = 0;
 434
 435   if (!servers)
 436     {
 437       servers = dns_servers;
 438       n_servers = dns_nservers;
 439     }
 440
 441   if (!n_servers)
 442     return grub_error (GRUB_ERR_BAD_ARGUMENT,
 443                        N_("no DNS servers configured"));
 444
 445   *naddresses = 0;
 446   if (cache)
 447     {
 448       int h;
 449       h = hash (name);
 450       if (dns_cache[h].name && grub_strcmp (dns_cache[h].name, name) == 0
 451           && grub_get_time_ms () < dns_cache[h].limit_time)
 452         {
 453           grub_dprintf ("dns", "retrieved from cache\n");
 454           *addresses = grub_malloc (dns_cache[h].naddresses
 455                                     * sizeof ((*addresses)[0]));
 456           if (!*addresses)
 457             return grub_errno;
 458           *naddresses = dns_cache[h].naddresses;
 459           grub_memcpy (*addresses, dns_cache[h].addresses,
 460                        dns_cache[h].naddresses
 461                        * sizeof ((*addresses)[0]));
 462           return GRUB_ERR_NONE;
 463         }
 464     }
 465
 466   data.name = grub_strdup (name);
 467   if (!data.name)
 468     return grub_errno;
 469
 470   nb = grub_netbuff_alloc (GRUB_NET_OUR_MAX_IP_HEADER_SIZE
 471                            + GRUB_NET_MAX_LINK_HEADER_SIZE
 472                            + GRUB_NET_UDP_HEADER_SIZE
 473                            + sizeof (struct dns_header)
 474                            + grub_strlen (name) + 2 + 4
 475                            + 2 + 4);
 476   if (!nb)
 477     {
 478       grub_free (data.name);
 479       return grub_errno;
 480     }
 481   grub_netbuff_reserve (nb, GRUB_NET_OUR_MAX_IP_HEADER_SIZE
 482                         + GRUB_NET_MAX_LINK_HEADER_SIZE
 483                         + GRUB_NET_UDP_HEADER_SIZE);
 484   grub_netbuff_put (nb, sizeof (struct dns_header)
 485                     + grub_strlen (name) + 2 + 4 + 2 + 4);
 486   head = (struct dns_header *) nb->data;
 487   optr = (grub_uint8_t *) (head + 1);
 488   for (iptr = name; *iptr; )
 489     {
 490       const char *dot;
 491       dot = grub_strchr (iptr, '.');
 492       if (!dot)
 493         dot = iptr + grub_strlen (iptr);
 494       if ((dot - iptr) >= 64)
 495         {
 496           grub_free (data.name);
 497           return grub_error (GRUB_ERR_BAD_ARGUMENT,
 498                              N_("domain name component is too long"));
 499         }
 500       *optr = (dot - iptr);
 501       optr++;
 502       grub_memcpy (optr, iptr, dot - iptr);
 503       optr += dot - iptr;
 504       iptr = dot;
 505       if (*iptr)
 506         iptr++;
 507     }
 508   *optr++ = 0;
 509
 510   /* Type: A.  */
 511   *optr++ = 0;
 512   *optr++ = 1;
 513
 514   /* Class.  */
 515   *optr++ = 0;
 516   *optr++ = 1;
 517
 518   /* Compressed name.  */
 519   *optr++ = 0xc0;
 520   *optr++ = 0x0c;
 521   /* Type: AAAA.  */
 522   *optr++ = 0;
 523   *optr++ = 28;
 524
 525   /* Class.  */
 526   *optr++ = 0;
 527   *optr++ = 1;
 528
 529   head->id = data.id;
 530   head->flags = FLAGS_RD;
 531   head->ra_z_r_code = 0;
 532   head->qdcount = grub_cpu_to_be16_compile_time (2);
 533   head->ancount = grub_cpu_to_be16_compile_time (0);
 534   head->nscount = grub_cpu_to_be16_compile_time (0);
 535   head->arcount = grub_cpu_to_be16_compile_time (0);
 536
 537   nbd = nb->data;
 538
 539   for (i = 0; i < n_servers * 4; i++)
 540     {
 541       /* Connect to a next server.  */
 542       while (!(i & 1) && send_servers < n_servers)
 543         {
 544           sockets[send_servers] = grub_net_udp_open (servers[send_servers],
 545                                                      DNS_PORT,
 546                                                      recv_hook,
 547                                                      &data);
 548           send_servers++;
 549           if (!sockets[send_servers - 1])
 550             {
 551               err = grub_errno;
 552               grub_errno = GRUB_ERR_NONE;
 553             }
 554           else
 555             {
 556               have_server = 1;
 557               break;
 558             }
 559         }
 560       if (!have_server)
 561         goto out;
 562       if (*data.naddresses)
 563         goto out;
 564       for (j = 0; j < send_servers; j++)
 565         {
 566           grub_err_t err2;
 567           if (!sockets[j])
 568             continue;
 569           nb->data = nbd;
 570           err2 = grub_net_send_udp_packet (sockets[j], nb);
 571           if (err2)
 572             {
 573               grub_errno = GRUB_ERR_NONE;
 574               err = err2;
 575             }
 576           if (*data.naddresses)
 577             goto out;
 578         }
 579       grub_net_poll_cards (200, &data.stop);
 580     }
 581  out:
 582   grub_free (data.name);
 583   grub_netbuff_free (nb);
 584   for (j = 0; j < send_servers; j++)
 585     grub_net_udp_close (sockets[j]);
 586
 587   if (*data.naddresses)
 588     return GRUB_ERR_NONE;
 589   if (data.dns_err)
 590     return grub_error (GRUB_ERR_NET_NO_DOMAIN,
 591                        N_("no DNS record found"));
 592
 593   if (err)
 594     {
 595       grub_errno = err;
 596       return err;
 597     }
 598   return grub_error (GRUB_ERR_TIMEOUT,
 599                      N_("no DNS reply received"));
 600 }
 601
 602 static grub_err_t
 603 grub_cmd_nslookup (struct grub_command *cmd __attribute__ ((unused)),
 604                    int argc, char **args)
 605 {
 606   grub_err_t err;
 607   grub_size_t naddresses, i;
 608   struct grub_net_network_level_address *addresses = 0;
 609   if (argc != 2 && argc != 1)
 610     return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("two arguments expected"));
 611   if (argc == 2)
 612     {
 613       struct grub_net_network_level_address server;
 614       err = grub_net_resolve_address (args[1], &server);
 615       if (err)
 616         return err;
 617       err = grub_net_dns_lookup (args[0], &server, 1, &naddresses,
 618                                  &addresses, 0);
 619     }
 620   else
 621     err = grub_net_dns_lookup (args[0], dns_servers, dns_nservers, &naddresses,
 622                                &addresses, 0);
 623
 624   for (i = 0; i < naddresses; i++)
 625     {
 626       char buf[GRUB_NET_MAX_STR_ADDR_LEN];
 627       grub_net_addr_to_str (&addresses[i], buf);
 628       grub_printf ("%s\n", buf);
 629     }
 630   grub_free (addresses);
 631   return GRUB_ERR_NONE;
 632 }
 633
 634 static grub_err_t
 635 grub_cmd_list_dns (struct grub_command *cmd __attribute__ ((unused)),
 636                    int argc __attribute__ ((unused)),
 637                    char **args __attribute__ ((unused)))
 638 {
 639   grub_size_t i;
 640   for (i = 0; i < dns_nservers; i++)
 641     {
 642       char buf[GRUB_NET_MAX_STR_ADDR_LEN];
 643       grub_net_addr_to_str (&dns_servers[i], buf);
 644       grub_printf ("%s\n", buf);
 645     }
 646   return GRUB_ERR_NONE;
 647 }
 648
 649 static grub_err_t
 650 grub_cmd_add_dns (struct grub_command *cmd __attribute__ ((unused)),
 651                   int argc, char **args)
 652 {
 653   grub_err_t err;
 654   struct grub_net_network_level_address server;
 655
 656   if (argc != 1)
 657     return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
 658   err = grub_net_resolve_address (args[0], &server);
 659   if (err)
 660     return err;
 661
 662   return grub_net_add_dns_server (&server);
 663 }
 664
 665 static grub_err_t
 666 grub_cmd_del_dns (struct grub_command *cmd __attribute__ ((unused)),
 667                   int argc, char **args)
 668 {
 669   grub_err_t err;
 670   struct grub_net_network_level_address server;
 671
 672   if (argc != 1)
 673     return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
 674   err = grub_net_resolve_address (args[1], &server);
 675   if (err)
 676     return err;
 677
 678   return grub_net_add_dns_server (&server);
 679 }
 680
 681 static grub_command_t cmd, cmd_add, cmd_del, cmd_list;
 682
 683 void
 684 grub_dns_init (void)
 685 {
 686   cmd = grub_register_command ("net_nslookup", grub_cmd_nslookup,
 687                                N_("ADDRESS DNSSERVER"),
 688                                N_("Perform a DNS lookup"));
 689   cmd_add = grub_register_command ("net_add_dns", grub_cmd_add_dns,
 690                                    N_("DNSSERVER"),
 691                                    N_("Add a DNS server"));
 692   cmd_del = grub_register_command ("net_del_dns", grub_cmd_del_dns,
 693                                    N_("DNSSERVER"),
 694                                    N_("Remove a DNS server"));
 695   cmd_list = grub_register_command ("net_ls_dns", grub_cmd_list_dns,
 696                                    NULL, N_("List DNS servers"));
 697 }
 698
 699 void
 700 grub_dns_fini (void)
 701 {
 702   grub_unregister_command (cmd);
 703   grub_unregister_command (cmd_add);
 704   grub_unregister_command (cmd_del);
 705   grub_unregister_command (cmd_list);
 706 }