libexec/dma/dns.c

   1 /*
   2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Simon 'corecode' Schubert <corecode@fs.ei.tum.de>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/types.h>
  36 #include <netinet/in.h>
  37 #include <arpa/inet.h>
  38 #include <arpa/nameser.h>
  39 #include <errno.h>
  40 #include <netdb.h>
  41 #include <resolv.h>
  42 #include <string.h>
  43 #include <stdlib.h>
  44
  45 #include "dma.h"
  46
  47 static int
  48 sort_pref(const void *a, const void *b)
  49 {
  50         const struct mx_hostentry *ha = a, *hb = b;
  51         int v;
  52
  53         /* sort increasing by preference primarily */
  54         v = ha->pref - hb->pref;
  55         if (v != 0)
  56                 return (v);
  57
  58         /* sort PF_INET6 before PF_INET */
  59         v = - (ha->ai.ai_family - hb->ai.ai_family);
  60         return (v);
  61 }
  62
  63 static int
  64 add_host(int pref, const char *host, int port, struct mx_hostentry **he, size_t *ps)
  65 {
  66         struct addrinfo hints, *res, *res0 = NULL;
  67         char servname[10];
  68         struct mx_hostentry *p;
  69         const int count_inc = 10;
  70         int err;
  71
  72         memset(&hints, 0, sizeof(hints));
  73         hints.ai_family = PF_UNSPEC;
  74         hints.ai_socktype = SOCK_STREAM;
  75         hints.ai_protocol = IPPROTO_TCP;
  76
  77         snprintf(servname, sizeof(servname), "%d", port);
  78         err = getaddrinfo(host, servname, &hints, &res0);
  79         if (err)
  80                 return (err == EAI_AGAIN ? 1 : -1);
  81
  82         for (res = res0; res != NULL; res = res->ai_next) {
  83                 if (*ps + 1 >= roundup(*ps, count_inc)) {
  84                         size_t newsz = roundup(*ps + 2, count_inc);
  85                         *he = reallocf(*he, newsz * sizeof(**he));
  86                         if (*he == NULL)
  87                                 goto out;
  88                 }
  89
  90                 p = &(*he)[*ps];
  91                 strlcpy(p->host, host, sizeof(p->host));
  92                 p->pref = pref;
  93                 p->ai = *res;
  94                 p->ai.ai_addr = NULL;
  95                 bcopy(res->ai_addr, &p->sa, p->ai.ai_addrlen);
  96
  97                 getnameinfo((struct sockaddr *)&p->sa, p->ai.ai_addrlen,
  98                             p->addr, sizeof(p->addr),
  99                             NULL, 0, NI_NUMERICHOST);
 100
 101                 (*ps)++;
 102         }
 103         freeaddrinfo(res0);
 104
 105         return (0);
 106
 107 out:
 108         if (res0 != NULL)
 109                 freeaddrinfo(res0);
 110         return (1);
 111 }
 112
 113 int
 114 dns_get_mx_list(const char *host, int port, struct mx_hostentry **he, int no_mx)
 115 {
 116         char outname[MAXDNAME];
 117         ns_msg msg;
 118         ns_rr rr;
 119         const char *searchhost;
 120         const unsigned char *cp;
 121         unsigned char *ans;
 122         struct mx_hostentry *hosts = NULL;
 123         size_t nhosts = 0;
 124         size_t anssz;
 125         int pref;
 126         int cname_recurse;
 127         int have_mx = 0;
 128         int err;
 129         int i;
 130
 131         res_init();
 132         searchhost = host;
 133         cname_recurse = 0;
 134
 135         anssz = 65536;
 136         ans = malloc(anssz);
 137         if (ans == NULL)
 138                 return (1);
 139
 140         if (no_mx)
 141                 goto out;
 142
 143 repeat:
 144         err = res_search(searchhost, ns_c_in, ns_t_mx, ans, anssz);
 145         if (err < 0) {
 146                 switch (h_errno) {
 147                 case NO_DATA:
 148                         /*
 149                          * Host exists, but no MX (or CNAME) entry.
 150                          * Not an error, use host name instead.
 151                          */
 152                         goto out;
 153                 case TRY_AGAIN:
 154                         /* transient error */
 155                         goto transerr;
 156                 case NO_RECOVERY:
 157                 case HOST_NOT_FOUND:
 158                 default:
 159                         errno = ENOENT;
 160                         goto err;
 161                 }
 162         }
 163
 164         if (!ns_initparse(ans, anssz, &msg))
 165                 goto transerr;
 166
 167         switch (ns_msg_getflag(msg, ns_f_rcode)) {
 168         case ns_r_noerror:
 169                 break;
 170         case ns_r_nxdomain:
 171                 goto err;
 172         default:
 173                 goto transerr;
 174         }
 175
 176         for (i = 0; i < ns_msg_count(msg, ns_s_an); i++) {
 177                 if (ns_parserr(&msg, ns_s_an, i, &rr))
 178                         goto transerr;
 179
 180                 cp = ns_rr_rdata(rr);
 181
 182                 switch (ns_rr_type(rr)) {
 183                 case ns_t_mx:
 184                         have_mx = 1;
 185                         pref = ns_get16(cp);
 186                         cp += 2;
 187                         err = ns_name_uncompress(ns_msg_base(msg), ns_msg_end(msg),
 188                                                  cp, outname, sizeof(outname));
 189                         if (err < 0)
 190                                 goto transerr;
 191
 192                         err = add_host(pref, outname, port, &hosts, &nhosts);
 193                         if (err == -1)
 194                                 goto err;
 195                         break;
 196
 197                 case ns_t_cname:
 198                         err = ns_name_uncompress(ns_msg_base(msg), ns_msg_end(msg),
 199                                                  cp, outname, sizeof(outname));
 200                         if (err < 0)
 201                                 goto transerr;
 202
 203                         /* Prevent a CNAME loop */
 204                         if (cname_recurse++ > 10)
 205                                 goto err;
 206
 207                         searchhost = outname;
 208                         goto repeat;
 209
 210                 default:
 211                         break;
 212                 }
 213         }
 214
 215 out:
 216         err = 0;
 217         if (0) {
 218 transerr:
 219                 if (nhosts == 0)
 220                         err = 1;
 221         }
 222         if (0) {
 223 err:
 224                 err = -1;
 225         }
 226
 227         free(ans);
 228
 229         if (err == 0) {
 230                 if (!have_mx) {
 231                         /*
 232                          * If we didn't find any MX, use the hostname instead.
 233                          */
 234                         err = add_host(0, host, port, &hosts, &nhosts);
 235                 } else if (nhosts == 0) {
 236                         /*
 237                          * We did get MX, but couldn't resolve any of them
 238                          * due to transient errors.
 239                          */
 240                         err = 1;
 241                 }
 242         }
 243
 244         if (nhosts > 0) {
 245                 qsort(hosts, nhosts, sizeof(*hosts), sort_pref);
 246                 /* terminate list */
 247                 *hosts[nhosts].host = 0;
 248         } else {
 249                 if (hosts != NULL)
 250                         free(hosts);
 251                 hosts = NULL;
 252         }
 253
 254         *he = hosts;
 255         return (err);
 256
 257         free(ans);
 258         if (hosts != NULL)
 259                 free(hosts);
 260         return (err);
 261 }
 262
 263 #if defined(TESTING)
 264 int
 265 main(int argc, char **argv)
 266 {
 267         struct mx_hostentry *he, *p;
 268         int err;
 269
 270         err = dns_get_mx_list(argv[1], 53, &he, 0);
 271         if (err)
 272                 return (err);
 273
 274         for (p = he; *p->host != 0; p++) {
 275                 printf("%d\t%s\t%s\n", p->pref, p->host, p->addr);
 276         }
 277
 278         return (0);
 279 }
 280 #endif