ircd/dns.c

   1 /*
   2  *  dns.c: An interface to the resolver module in authd
   3  *  (based somewhat on ircd-ratbox dns.c)
   4  *
   5  *  Copyright (C) 2005 Aaron Sethman <androsyn@ratbox.org>
   6  *  Copyright (C) 2005-2012 ircd-ratbox development team
   7  *  Copyright (C) 2016 William Pitcock <nenolod@dereferenced.org>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  22  *  USA
  23  */
  24
  25 #include "stdinc.h"
  26 #include "rb_lib.h"
  27 #include "client.h"
  28 #include "ircd_defs.h"
  29 #include "parse.h"
  30 #include "dns.h"
  31 #include "match.h"
  32 #include "logger.h"
  33 #include "s_conf.h"
  34 #include "client.h"
  35 #include "send.h"
  36 #include "numeric.h"
  37 #include "msg.h"
  38 #include "hash.h"
  39
  40 #define DNS_HOST_IPV4           ((char)'4')
  41 #define DNS_HOST_IPV6           ((char)'6')
  42 #define DNS_REVERSE_IPV4        ((char)'R')
  43 #define DNS_REVERSE_IPV6        ((char)'S')
  44
  45 static void submit_dns(uint32_t uid, char type, const char *addr);
  46 static void submit_dns_stat(uint32_t uid);
  47
  48 struct dnsreq
  49 {
  50         DNSCB callback;
  51         void *data;
  52 };
  53
  54 struct dnsstatreq
  55 {
  56         DNSLISTCB callback;
  57         void *data;
  58 };
  59
  60 /* These serve as a form of sparse array */
  61 static rb_dictionary *query_dict;
  62 static rb_dictionary *stat_dict;
  63
  64 rb_dlink_list nameservers;
  65
  66 static uint32_t query_id = 0;
  67 static uint32_t stat_id = 0;
  68
  69
  70 static inline uint32_t
  71 assign_id(uint32_t *id)
  72 {
  73         if(++(*id) == 0)
  74                 *id = 1;
  75
  76         return *id;
  77 }
  78
  79 static void
  80 handle_dns_failure(uint32_t xid)
  81 {
  82         struct dnsreq *req = rb_dictionary_retrieve(query_dict, RB_UINT_TO_POINTER(xid));
  83         s_assert(req);
  84
  85         if(req->callback == NULL)
  86                 return;
  87
  88         req->callback("FAILED", 0, 0, req->data);
  89         req->callback = NULL;
  90         req->data = NULL;
  91 }
  92
  93 static void
  94 handle_dns_stat_failure(uint32_t xid)
  95 {
  96         struct dnsstatreq *req = rb_dictionary_retrieve(stat_dict, RB_UINT_TO_POINTER(xid));
  97         s_assert(req);
  98
  99         if(req->callback == NULL)
 100                 return;
 101
 102         req->callback(1, NULL, 2, req->data);
 103         req->callback = NULL;
 104         req->data = NULL;
 105 }
 106
 107
 108 void
 109 cancel_lookup(uint32_t xid)
 110 {
 111         struct dnsreq *req = rb_dictionary_retrieve(query_dict, RB_UINT_TO_POINTER(xid));
 112         s_assert(req);
 113         req->callback = NULL;
 114         req->data = NULL;
 115 }
 116
 117 void
 118 cancel_dns_stats(uint32_t xid)
 119 {
 120         struct dnsstatreq *req = rb_dictionary_retrieve(stat_dict, RB_UINT_TO_POINTER(xid));
 121         s_assert(req);
 122         req->callback = NULL;
 123         req->data = NULL;
 124 }
 125
 126
 127 uint32_t
 128 lookup_hostname(const char *hostname, int aftype, DNSCB callback, void *data)
 129 {
 130         struct dnsreq *req = rb_malloc(sizeof(struct dnsreq));
 131         int aft;
 132         uint32_t rid = assign_id(&query_id);
 133
 134         check_authd();
 135
 136         rb_dictionary_add(query_dict, RB_UINT_TO_POINTER(rid), req);
 137
 138         req->callback = callback;
 139         req->data = data;
 140
 141 #ifdef RB_IPV6
 142         if(aftype == AF_INET6)
 143                 aft = 6;
 144         else
 145 #endif
 146                 aft = 4;
 147
 148         submit_dns(rid, aft == 4 ? DNS_HOST_IPV4 : DNS_HOST_IPV6, hostname);
 149         return (rid);
 150 }
 151
 152 uint32_t
 153 lookup_ip(const char *addr, int aftype, DNSCB callback, void *data)
 154 {
 155         struct dnsreq *req = rb_malloc(sizeof(struct dnsreq));
 156         int aft;
 157         uint32_t rid = assign_id(&query_id);
 158
 159         check_authd();
 160
 161         rb_dictionary_add(query_dict, RB_UINT_TO_POINTER(rid), req);
 162
 163         req->callback = callback;
 164         req->data = data;
 165
 166 #ifdef RB_IPV6
 167         if(aftype == AF_INET6)
 168                 aft = 6;
 169         else
 170 #endif
 171                 aft = 4;
 172
 173         submit_dns(rid, aft == 4 ? DNS_REVERSE_IPV4 : DNS_REVERSE_IPV6, addr);
 174         return (rid);
 175 }
 176
 177 static uint32_t
 178 get_nameservers(DNSLISTCB callback, void *data)
 179 {
 180         struct dnsstatreq *req = rb_malloc(sizeof(struct dnsstatreq));
 181         uint32_t qid = assign_id(&stat_id);
 182
 183         check_authd();
 184
 185         rb_dictionary_add(stat_dict, RB_UINT_TO_POINTER(qid), req);
 186
 187         req->callback = callback;
 188         req->data = data;
 189
 190         submit_dns_stat(qid);
 191         return (qid);
 192 }
 193
 194
 195 void
 196 dns_results_callback(const char *callid, const char *status, const char *type, const char *results)
 197 {
 198         struct dnsreq *req;
 199         uint32_t rid;
 200         int st;
 201         int aft;
 202         long lrid = strtol(callid, NULL, 16);
 203
 204         if(lrid > UINT32_MAX)
 205                 return;
 206
 207         rid = (uint32_t)lrid;
 208         req = rb_dictionary_retrieve(query_dict, RB_UINT_TO_POINTER(rid));
 209         if(req == NULL)
 210                 return;
 211
 212         st = (*status == 'O');
 213         aft = *type == '6' || *type == 'S' ? 6 : 4;
 214         if(req->callback == NULL)
 215         {
 216                 /* got cancelled..oh well */
 217                 req->data = NULL;
 218                 return;
 219         }
 220 #ifdef RB_IPV6
 221         if(aft == 6)
 222                 aft = AF_INET6;
 223         else
 224 #endif
 225                 aft = AF_INET;
 226
 227         req->callback(results, st, aft, req->data);
 228
 229         rb_free(req);
 230         rb_dictionary_delete(query_dict, RB_UINT_TO_POINTER(rid));
 231 }
 232
 233 void
 234 dns_stats_results_callback(const char *callid, const char *status, int resc, const char *resv[])
 235 {
 236         struct dnsstatreq *req;
 237         uint32_t qid;
 238         int st;
 239         long lqid = strtol(callid, NULL, 16);
 240
 241         if(lqid > UINT32_MAX)
 242                 return;
 243
 244         qid = (uint32_t)lqid;
 245         req = rb_dictionary_retrieve(stat_dict, RB_UINT_TO_POINTER(qid));
 246
 247         s_assert(req);
 248
 249         if(req->callback == NULL)
 250         {
 251                 req->data = NULL;
 252                 return;
 253         }
 254
 255         switch(*status)
 256         {
 257         case 'Y':
 258                 st = 0;
 259                 break;
 260         case 'X':
 261                 /* Error */
 262                 st = 1;
 263                 break;
 264         default:
 265                 /* Shouldn't happen... */
 266                 return;
 267         }
 268
 269         /* Query complete */
 270         req->callback(resc, resv, st, req->data);
 271
 272         rb_free(req);
 273         rb_dictionary_delete(stat_dict, RB_UINT_TO_POINTER(qid));
 274 }
 275
 276 static void
 277 stats_results_callback(int resc, const char *resv[], int status, void *data)
 278 {
 279         if(status == 0)
 280         {
 281                 rb_dlink_node *n, *tn;
 282
 283                 RB_DLINK_FOREACH_SAFE(n, tn, nameservers.head)
 284                 {
 285                         /* Clean up old nameservers */
 286                         rb_free(n->data);
 287                         rb_dlinkDestroy(n, &nameservers);
 288                 }
 289
 290                 for(int i = 0; i < resc; i++)
 291                         rb_dlinkAddAlloc(rb_strdup(resv[i]), &nameservers);
 292         }
 293         else
 294         {
 295                 const char *error = resc ? resv[resc] : "Unknown error";
 296                 iwarn("Error getting DNS servers: %s", error);
 297         }
 298 }
 299
 300
 301 void
 302 init_dns(void)
 303 {
 304         query_dict = rb_dictionary_create("dns queries", rb_uint32cmp);
 305         stat_dict = rb_dictionary_create("dns stat queries", rb_uint32cmp);
 306         (void)get_nameservers(stats_results_callback, NULL);
 307 }
 308
 309 void
 310 reload_nameservers(void)
 311 {
 312         check_authd();
 313         rb_helper_write(authd_helper, "R D");
 314         (void)get_nameservers(stats_results_callback, NULL);
 315 }
 316
 317
 318 static void
 319 submit_dns(uint32_t nid, char type, const char *addr)
 320 {
 321         if(authd_helper == NULL)
 322         {
 323                 handle_dns_failure(nid);
 324                 return;
 325         }
 326         rb_helper_write(authd_helper, "D %x %c %s", nid, type, addr);
 327 }
 328
 329 static void
 330 submit_dns_stat(uint32_t nid)
 331 {
 332         if(authd_helper == NULL)
 333         {
 334                 handle_dns_stat_failure(nid);
 335                 return;
 336         }
 337         rb_helper_write(authd_helper, "S %x D", nid);
 338 }