authd/dns.c

   1 /* authd/dns.c - authd DNS functions
   2  * Copyright (c) 2016 William Pitcock <nenolod@dereferenced.org>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice is present in all copies.
   7  *
   8  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   9  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  10  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  11  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  12  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  13  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  14  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  15  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  16  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  17  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  18  * POSSIBILITY OF SUCH DAMAGE.
  19  */
  20
  21 #include "authd.h"
  22 #include "dns.h"
  23 #include "notice.h"
  24 #include "res.h"
  25
  26 static void handle_lookup_ip_reply(void *data, struct DNSReply *reply);
  27 static void handle_lookup_hostname_reply(void *data, struct DNSReply *reply);
  28
  29 uint64_t query_count = 0;
  30
  31 /* A bit different from ircd... you just get a dns_query object.
  32  *
  33  * It gets freed whenever the res code gets back to us.
  34  */
  35 struct dns_query *
  36 lookup_ip(const char *host, int aftype, DNSCB callback, void *data)
  37 {
  38         struct dns_query *query = rb_malloc(sizeof(struct dns_query));
  39         int g_type;
  40
  41         if(aftype == AF_INET)
  42         {
  43                 query->type = QUERY_A;
  44                 g_type = T_A;
  45         }
  46 #ifdef RB_IPV6
  47         else if(aftype == AF_INET6)
  48         {
  49                 query->type = QUERY_AAAA;
  50                 g_type = T_AAAA;
  51         }
  52 #endif
  53         else
  54         {
  55                 rb_free(query);
  56                 return NULL;
  57         }
  58
  59         query->id = query_count++;
  60         query->callback = callback;
  61         query->data = data;
  62
  63         query->query.ptr = query;
  64         query->query.callback = handle_lookup_ip_reply;
  65
  66         gethost_byname_type(host, &query->query, g_type);
  67
  68         return query;
  69 }
  70
  71 /* See lookup_ip's comment */
  72 struct dns_query *
  73 lookup_hostname(const char *ip, DNSCB callback, void *data)
  74 {
  75         struct dns_query *query = rb_malloc(sizeof(struct dns_query));
  76         int aftype;
  77
  78         if(!rb_inet_pton_sock(ip, (struct sockaddr *)&query->addr))
  79         {
  80                 rb_free(query);
  81                 return NULL;
  82         }
  83
  84         aftype = GET_SS_FAMILY(&query->addr);
  85
  86         if(aftype == AF_INET)
  87                 query->type = QUERY_PTR_A;
  88 #ifdef RB_IPV6
  89         else if(aftype == AF_INET6)
  90                 query->type = QUERY_PTR_AAAA;
  91 #endif
  92         else
  93         {
  94                 rb_free(query);
  95                 return NULL;
  96         }
  97
  98         query->id = query_count++;
  99         query->callback = callback;
 100         query->data = data;
 101
 102         query->query.ptr = query;
 103         query->query.callback = handle_lookup_hostname_reply;
 104
 105         gethost_byaddr(&query->addr, &query->query);
 106
 107         return query;
 108 }
 109
 110 /* Cancel a pending query */
 111 void
 112 cancel_query(struct dns_query *query)
 113 {
 114         query->callback = query->data = NULL;
 115 }
 116
 117 /* Callback from gethost_byname_type */
 118 static void
 119 handle_lookup_ip_reply(void *data, struct DNSReply *reply)
 120 {
 121         struct dns_query *query = data;
 122         char ip[HOSTIPLEN] = "*";
 123
 124         if(query == NULL)
 125         {
 126                 /* Shouldn't happen */
 127                 warn_opers(L_CRIT, "DNS: handle_lookup_ip_reply: query == NULL!");
 128                 exit(EX_DNS_ERROR);
 129         }
 130
 131         if(reply == NULL)
 132                 goto end;
 133
 134         switch(query->type)
 135         {
 136         case QUERY_A:
 137                 if(GET_SS_FAMILY(&reply->addr) == AF_INET)
 138                         rb_inet_ntop_sock((struct sockaddr *)&reply->addr, ip, sizeof(ip));
 139                 break;
 140 #ifdef RB_IPV6
 141         case QUERY_AAAA:
 142                 if(GET_SS_FAMILY(&reply->addr) == AF_INET6)
 143                 {
 144                         rb_inet_ntop_sock((struct sockaddr *)&reply->addr, ip, sizeof(ip));
 145                         if(ip[0] == ':')
 146                         {
 147                                 memmove(&ip[1], ip, strlen(ip));
 148                                 ip[0] = '0';
 149                         }
 150                 }
 151                 break;
 152 #endif
 153         default:
 154                 warn_opers(L_CRIT, "DNS: handle_lookup_ip_reply: unknown query type %d",
 155                                 query->type);
 156                 exit(EX_DNS_ERROR);
 157         }
 158
 159 end:
 160         if(query->callback)
 161                 query->callback(ip, ip[0] != '*', query->type, query->data);
 162
 163         rb_free(query);
 164 }
 165
 166 /* Callback from gethost_byaddr */
 167 static void
 168 handle_lookup_hostname_reply(void *data, struct DNSReply *reply)
 169 {
 170         struct dns_query *query = data;
 171         char *hostname = NULL;
 172
 173         if(query == NULL)
 174         {
 175                 /* Shouldn't happen */
 176                 warn_opers(L_CRIT, "DNS: handle_lookup_hostname_reply: query == NULL!");
 177                 exit(EX_DNS_ERROR);
 178         }
 179
 180         if(reply == NULL)
 181                 goto end;
 182
 183         if(query->type == QUERY_PTR_A)
 184         {
 185                 struct sockaddr_in *ip, *ip_fwd;
 186                 ip = (struct sockaddr_in *) &query->addr;
 187                 ip_fwd = (struct sockaddr_in *) &reply->addr;
 188
 189                 if(ip->sin_addr.s_addr == ip_fwd->sin_addr.s_addr)
 190                         hostname = reply->h_name;
 191         }
 192 #ifdef RB_IPV6
 193         else if(query->type == QUERY_PTR_AAAA)
 194         {
 195                 struct sockaddr_in6 *ip, *ip_fwd;
 196                 ip = (struct sockaddr_in6 *) &query->addr;
 197                 ip_fwd = (struct sockaddr_in6 *) &reply->addr;
 198
 199                 if(memcmp(&ip->sin6_addr, &ip_fwd->sin6_addr, sizeof(struct in6_addr)) == 0)
 200                         hostname = reply->h_name;
 201         }
 202 #endif
 203         else
 204         {
 205                 /* Shouldn't happen */
 206                 warn_opers(L_CRIT, "DNS: handle_lookup_hostname_reply: unknown query type %d",
 207                                 query->type);
 208                 exit(EX_DNS_ERROR);
 209         }
 210 end:
 211         if(query->callback)
 212                 query->callback(hostname, hostname != NULL, query->type, query->data);
 213
 214         rb_free(query);
 215 }
 216
 217 static void
 218 submit_dns_answer(const char *reply, bool status, query_type type, void *data)
 219 {
 220         char *id = data;
 221
 222         if(!id || type == QUERY_INVALID)
 223         {
 224                 warn_opers(L_CRIT, "DNS: submit_dns_answer gave us a bad query");
 225                 exit(EX_DNS_ERROR);
 226         }
 227
 228         if(reply == NULL || status == false)
 229         {
 230                 rb_helper_write(authd_helper, "E %s E %c *", id, type);
 231                 rb_free(id);
 232                 return;
 233         }
 234
 235         rb_helper_write(authd_helper, "E %s O %c %s", id, type, reply);
 236         rb_free(id);
 237 }
 238
 239 void
 240 handle_resolve_dns(int parc, char *parv[])
 241 {
 242         char *id = rb_strdup(parv[1]);
 243         char qtype = *parv[2];
 244         char *record = parv[3];
 245         int aftype = AF_INET;
 246
 247         switch(qtype)
 248         {
 249 #ifdef RB_IPV6
 250         case '6':
 251                 aftype = AF_INET6;
 252 #endif
 253         case '4':
 254                 if(!lookup_ip(record, aftype, submit_dns_answer, id))
 255                         submit_dns_answer(NULL, false, qtype, NULL);
 256                 break;
 257 #ifdef RB_IPV6
 258         case 'S':
 259 #endif
 260         case 'R':
 261                 if(!lookup_hostname(record, submit_dns_answer, id))
 262                         submit_dns_answer(NULL, false, qtype, NULL);
 263                 break;
 264         default:
 265                 warn_opers(L_CRIT, "DNS: handle_resolve_dns got an unknown query: %c", qtype);
 266                 exit(EX_DNS_ERROR);
 267         }
 268 }
 269
 270 void
 271 enumerate_nameservers(uint32_t rid, const char letter)
 272 {
 273         char buf[(HOSTIPLEN + 1) * IRCD_MAXNS];
 274         size_t s = 0;
 275
 276         if (!irc_nscount)
 277         {
 278                 /* Shouldn't happen */
 279                 warn_opers(L_CRIT, "DNS: no name servers!");
 280                 stats_error(rid, letter, "NONAMESERVERS");
 281                 exit(EX_DNS_ERROR);
 282         }
 283
 284         for(int i = 0; i < irc_nscount; i++)
 285         {
 286                 char addr[HOSTIPLEN];
 287                 size_t addrlen;
 288
 289                 rb_inet_ntop_sock((struct sockaddr *)&irc_nsaddr_list[i], addr, sizeof(addr));
 290
 291                 if (!addr[0])
 292                 {
 293                         /* Shouldn't happen */
 294                         warn_opers(L_CRIT, "DNS: bad nameserver!");
 295                         stats_error(rid, letter, "INVALIDNAMESERVER");
 296                         exit(EX_DNS_ERROR);
 297                 }
 298
 299                 addrlen = strlen(addr) + 1;
 300                 (void)snprintf(&buf[s], sizeof(buf) - s, "%s ", addr);
 301                 s += addrlen;
 302         }
 303
 304         if(s > 0)
 305                 buf[--s] = '\0';
 306
 307         stats_result(rid, letter, "%s", buf);
 308 }
 309
 310 void
 311 reload_nameservers(const char letter)
 312 {
 313         /* Not a whole lot to it */
 314         restart_resolver();
 315 }