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 struct Dictionary *query_dict;
  62 static struct 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 #define ASSIGN_ID(id) (id++)
  70
  71
  72 static void
  73 handle_dns_failure(uint32_t xid)
  74 {
  75         struct dnsreq *req = rb_dictionary_retrieve(query_dict, RB_UINT_TO_POINTER(xid));
  76         s_assert(req);
  77
  78         if(req->callback == NULL)
  79                 return;
  80
  81         req->callback("FAILED", 0, 0, req->data);
  82         req->callback = NULL;
  83         req->data = NULL;
  84 }
  85
  86 static void
  87 handle_dns_stat_failure(uint32_t xid)
  88 {
  89         struct dnsstatreq *req = rb_dictionary_retrieve(stat_dict, RB_UINT_TO_POINTER(xid));
  90         s_assert(req);
  91
  92         if(req->callback == NULL)
  93                 return;
  94
  95         req->callback(1, NULL, 2, req->data);
  96         req->callback = NULL;
  97         req->data = NULL;
  98 }
  99
 100
 101 void
 102 cancel_lookup(uint32_t xid)
 103 {
 104         struct dnsreq *req = rb_dictionary_retrieve(query_dict, RB_UINT_TO_POINTER(xid));
 105         s_assert(req);
 106         req->callback = NULL;
 107         req->data = NULL;
 108 }
 109
 110 void
 111 cancel_dns_stats(uint32_t xid)
 112 {
 113         struct dnsstatreq *req = rb_dictionary_retrieve(stat_dict, RB_UINT_TO_POINTER(xid));
 114         s_assert(req);
 115         req->callback = NULL;
 116         req->data = NULL;
 117 }
 118
 119
 120 uint32_t
 121 lookup_hostname(const char *hostname, int aftype, DNSCB callback, void *data)
 122 {
 123         struct dnsreq *req = rb_malloc(sizeof(struct dnsreq));
 124         int aft;
 125         uint32_t rid = ASSIGN_ID(query_id);
 126
 127         check_authd();
 128
 129         rb_dictionary_add(query_dict, RB_UINT_TO_POINTER(rid), req);
 130
 131         req->callback = callback;
 132         req->data = data;
 133
 134 #ifdef RB_IPV6
 135         if(aftype == AF_INET6)
 136                 aft = 6;
 137         else
 138 #endif
 139                 aft = 4;
 140
 141         submit_dns(rid, aft == 4 ? DNS_HOST_IPV4 : DNS_HOST_IPV6, hostname);
 142         return (rid);
 143 }
 144
 145 uint32_t
 146 lookup_ip(const char *addr, int aftype, DNSCB callback, void *data)
 147 {
 148         struct dnsreq *req = rb_malloc(sizeof(struct dnsreq));
 149         int aft;
 150         uint32_t rid = ASSIGN_ID(query_id);
 151
 152         check_authd();
 153
 154         rb_dictionary_add(query_dict, RB_UINT_TO_POINTER(rid), req);
 155
 156         req->callback = callback;
 157         req->data = data;
 158
 159 #ifdef RB_IPV6
 160         if(aftype == AF_INET6)
 161                 aft = 6;
 162         else
 163 #endif
 164                 aft = 4;
 165
 166         submit_dns(rid, aft == 4 ? DNS_REVERSE_IPV4 : DNS_REVERSE_IPV6, addr);
 167         return (rid);
 168 }
 169
 170 uint32_t
 171 get_nameservers(DNSLISTCB callback, void *data)
 172 {
 173         struct dnsstatreq *req = rb_malloc(sizeof(struct dnsstatreq));
 174         uint32_t qid = ASSIGN_ID(stat_id);
 175
 176         check_authd();
 177
 178         rb_dictionary_add(stat_dict, RB_UINT_TO_POINTER(qid), req);
 179
 180         req->callback = callback;
 181         req->data = data;
 182
 183         submit_dns_stat(qid);
 184         return (qid);
 185 }
 186
 187
 188 void
 189 dns_results_callback(const char *callid, const char *status, const char *type, const char *results)
 190 {
 191         struct dnsreq *req;
 192         uint32_t rid;
 193         int st;
 194         int aft;
 195         long lrid = strtol(callid, NULL, 16);
 196
 197         if(lrid > UINT32_MAX)
 198                 return;
 199
 200         rid = (uint32_t)lrid;
 201         req = rb_dictionary_retrieve(query_dict, RB_UINT_TO_POINTER(rid));
 202         if(req == NULL)
 203                 return;
 204
 205         st = (*status == 'O');
 206         aft = *type == '6' || *type == 'S' ? 6 : 4;
 207         if(req->callback == NULL)
 208         {
 209                 /* got cancelled..oh well */
 210                 req->data = NULL;
 211                 return;
 212         }
 213 #ifdef RB_IPV6
 214         if(aft == 6)
 215                 aft = AF_INET6;
 216         else
 217 #endif
 218                 aft = AF_INET;
 219
 220         req->callback(results, st, aft, req->data);
 221
 222         rb_free(req);
 223         rb_dictionary_delete(query_dict, RB_UINT_TO_POINTER(rid));
 224 }
 225
 226 void
 227 dns_stats_results_callback(const char *callid, const char *status, int resc, const char *resv[])
 228 {
 229         struct dnsstatreq *req;
 230         uint32_t qid;
 231         int st, i;
 232         long lqid = strtol(callid, NULL, 16);
 233
 234         if(lqid > UINT32_MAX)
 235                 return;
 236
 237         qid = (uint32_t)lqid;
 238         req = rb_dictionary_retrieve(stat_dict, RB_UINT_TO_POINTER(qid));
 239
 240         s_assert(req);
 241
 242         if(req->callback == NULL)
 243         {
 244                 req->data = NULL;
 245                 return;
 246         }
 247
 248         switch(*status)
 249         {
 250         case 'Y':
 251                 st = 0;
 252                 break;
 253         case 'X':
 254                 /* Error */
 255                 st = 1;
 256                 break;
 257         default:
 258                 /* Shouldn't happen... */
 259                 return;
 260         }
 261
 262         /* Query complete */
 263         req->callback(resc, resv, st, req->data);
 264
 265         rb_free(req);
 266         rb_dictionary_delete(stat_dict, RB_UINT_TO_POINTER(qid));
 267 }
 268
 269 static void
 270 stats_results_callback(int resc, const char *resv[], int status, void *data)
 271 {
 272         if(status == 0)
 273         {
 274                 rb_dlink_node *n, *tn;
 275
 276                 RB_DLINK_FOREACH_SAFE(n, tn, nameservers.head)
 277                 {
 278                         /* Clean up old nameservers */
 279                         rb_free(n->data);
 280                         rb_dlinkDestroy(n, &nameservers);
 281                 }
 282
 283                 for(int i = 0; i < resc; i++)
 284                         rb_dlinkAddAlloc(rb_strdup(resv[i]), &nameservers);
 285         }
 286         else
 287         {
 288                 const char *error = resc ? resv[resc] : "Unknown error";
 289                 iwarn("Error getting DNS servers: %s", error);
 290         }
 291 }
 292
 293
 294 void
 295 init_dns(void)
 296 {
 297         query_dict = rb_dictionary_create("dns queries", rb_uint32cmp);
 298         stat_dict = rb_dictionary_create("dns stat queries", rb_uint32cmp);
 299         (void)get_nameservers(stats_results_callback, NULL);
 300 }
 301
 302 void
 303 reload_nameservers(void)
 304 {
 305         check_authd();
 306         rb_helper_write(authd_helper, "H D");
 307         (void)get_nameservers(stats_results_callback, NULL);
 308 }
 309
 310
 311 static void
 312 submit_dns(uint32_t nid, char type, const char *addr)
 313 {
 314         if(authd_helper == NULL)
 315         {
 316                 handle_dns_failure(nid);
 317                 return;
 318         }
 319         rb_helper_write(authd_helper, "D %x %c %s", nid, type, addr);
 320 }
 321
 322 static void
 323 submit_dns_stat(uint32_t nid)
 324 {
 325         if(authd_helper == NULL)
 326         {
 327                 handle_dns_stat_failure(nid);
 328                 return;
 329         }
 330         rb_helper_write(authd_helper, "S %x D", nid);
 331 }