networking/dnsd.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini DNS server implementation for busybox
   4  *
   5  * Copyright (C) 2005 Roberto A. Foglietta (me@roberto.foglietta.name)
   6  * Copyright (C) 2005 Odd Arild Olsen (oao at fibula dot no)
   7  * Copyright (C) 2003 Paul Sheer
   8  *
   9  * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  10  *
  11  * Odd Arild Olsen started out with the sheerdns [1] of Paul Sheer and rewrote
  12  * it into a shape which I believe is both easier to understand and maintain.
  13  * I also reused the input buffer for output and removed services he did not
  14  * need.  [1] http://threading.2038bug.com/sheerdns/
  15  *
  16  * Some bugfix and minor changes was applied by Roberto A. Foglietta who made
  17  * the first porting of oao' scdns to busybox also.
  18  */
  19
  20 #include "libbb.h"
  21 #include <syslog.h>
  22
  23 //#define DEBUG 1
  24 #define DEBUG 0
  25
  26 enum {
  27         /* can tweak this */
  28         DEFAULT_TTL = 120,
  29
  30         /* cannot get bigger packets than 512 per RFC1035. */
  31         MAX_PACK_LEN = 512,
  32         IP_STRING_LEN = sizeof(".xxx.xxx.xxx.xxx"),
  33         MAX_NAME_LEN = IP_STRING_LEN - 1 + sizeof(".in-addr.arpa"),
  34         REQ_A = 1,
  35         REQ_PTR = 12,
  36 };
  37
  38 /* the message from client and first part of response msg */
  39 struct dns_head {
  40         uint16_t id;
  41         uint16_t flags;
  42         uint16_t nquer;
  43         uint16_t nansw;
  44         uint16_t nauth;
  45         uint16_t nadd;
  46 };
  47 struct type_and_class {
  48         uint16_t type;
  49         uint16_t class;
  50 };
  51 /* element of known name, ip address and reversed ip address */
  52 struct dns_entry {
  53         struct dns_entry *next;
  54         uint32_t ip;
  55         char rip[IP_STRING_LEN]; /* length decimal reversed IP */
  56         char name[1];
  57 };
  58
  59 #define OPT_verbose (option_mask32)
  60
  61
  62 /*
  63  * Insert length of substrings instead of dots
  64  */
  65 static void undot(char *rip)
  66 {
  67         int i = 0;
  68         int s = 0;
  69
  70         while (rip[i])
  71                 i++;
  72         for (--i; i >= 0; i--) {
  73                 if (rip[i] == '.') {
  74                         rip[i] = s;
  75                         s = 0;
  76                 } else {
  77                         s++;
  78                 }
  79         }
  80 }
  81
  82 /*
  83  * Read hostname/IP records from file
  84  */
  85 static struct dns_entry *parse_conf_file(const char *fileconf)
  86 {
  87         char *token[2];
  88         parser_t *parser;
  89         struct dns_entry *m, *conf_data;
  90         struct dns_entry **nextp;
  91
  92         conf_data = NULL;
  93         nextp = &conf_data;
  94
  95         parser = config_open(fileconf);
  96         while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL)) {
  97                 struct in_addr ip;
  98                 uint32_t v32;
  99
 100                 if (inet_aton(token[1], &ip) == 0) {
 101                         bb_error_msg("error at line %u, skipping", parser->lineno);
 102                         continue;
 103                 }
 104
 105                 if (OPT_verbose)
 106                         bb_error_msg("name:%s, ip:%s", token[0], token[1]);
 107
 108                 /* sizeof(*m) includes 1 byte for m->name[0] */
 109                 m = xzalloc(sizeof(*m) + strlen(token[0]) + 1);
 110                 /*m->next = NULL;*/
 111                 *nextp = m;
 112                 nextp = &m->next;
 113
 114                 m->name[0] = '.';
 115                 strcpy(m->name + 1, token[0]);
 116                 undot(m->name);
 117                 m->ip = ip.s_addr; /* in network order */
 118                 v32 = ntohl(m->ip);
 119                 /* inverted order */
 120                 sprintf(m->rip, ".%u.%u.%u.%u",
 121                         (uint8_t)(v32),
 122                         (uint8_t)(v32 >> 8),
 123                         (uint8_t)(v32 >> 16),
 124                         (v32 >> 24)
 125                 );
 126                 undot(m->rip);
 127         }
 128         config_close(parser);
 129         return conf_data;
 130 }
 131
 132 /*
 133  * Look query up in dns records and return answer if found.
 134  */
 135 static char *table_lookup(struct dns_entry *d,
 136                 uint16_t type,
 137                 char* query_string)
 138 {
 139         while (d) {
 140                 unsigned len = d->name[0];
 141                 /* d->name[len] is the last (non NUL) char */
 142 #if DEBUG
 143                 char *p, *q;
 144                 q = query_string + 1;
 145                 p = d->name + 1;
 146                 fprintf(stderr, "%d/%d p:%s q:%s %d\n",
 147                         (int)strlen(p), len,
 148                         p, q, (int)strlen(q)
 149                 );
 150 #endif
 151                 if (type == htons(REQ_A)) {
 152                         /* search by host name */
 153                         if (len != 1 || d->name[1] != '*') {
 154 /* we are lax, hope no name component is ever >64 so that length
 155  * (which will be represented as 'A','B'...) matches a lowercase letter.
 156  * Actually, I think false matches are hard to construct.
 157  * Example.
 158  * [31] len is represented as '1', [65] as 'A', [65+32] as 'a'.
 159  * [65]   <65 same chars>[31]<31 same chars>NUL
 160  * [65+32]<65 same chars>1   <31 same chars>NUL
 161  * This example seems to be the minimal case when false match occurs.
 162  */
 163                                 if (strcasecmp(d->name, query_string) != 0)
 164                                         goto next;
 165                         }
 166                         return (char *)&d->ip;
 167 #if DEBUG
 168                         fprintf(stderr, "Found IP:%x\n", (int)d->ip);
 169 #endif
 170                         return 0;
 171                 }
 172                 /* search by IP-address */
 173                 if ((len != 1 || d->name[1] != '*')
 174                 /* we assume (do not check) that query_string
 175                  * ends in ".in-addr.arpa" */
 176                  && strncmp(d->rip, query_string, strlen(d->rip)) == 0
 177                 ) {
 178 #if DEBUG
 179                         fprintf(stderr, "Found name:%s\n", d->name);
 180 #endif
 181                         return d->name;
 182                 }
 183  next:
 184                 d = d->next;
 185         }
 186
 187         return NULL;
 188 }
 189
 190 /*
 191  * Decode message and generate answer
 192  */
 193 /* RFC 1035
 194 ...
 195 Whenever an octet represents a numeric quantity, the left most bit
 196 in the diagram is the high order or most significant bit.
 197 That is, the bit labeled 0 is the most significant bit.
 198 ...
 199
 200 4.1.1. Header section format
 201       0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
 202     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 203     |                      ID                       |
 204     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 205     |QR|   OPCODE  |AA|TC|RD|RA| 0  0  0|   RCODE   |
 206     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 207     |                    QDCOUNT                    |
 208     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 209     |                    ANCOUNT                    |
 210     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 211     |                    NSCOUNT                    |
 212     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 213     |                    ARCOUNT                    |
 214     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 215 ID      16 bit random identifier assigned by querying peer.
 216         Used to match query/response.
 217 QR      message is a query (0), or a response (1).
 218 OPCODE  0   standard query (QUERY)
 219         1   inverse query (IQUERY)
 220         2   server status request (STATUS)
 221 AA      Authoritative Answer - this bit is valid in responses.
 222         Responding name server is an authority for the domain name
 223         in question section. Answer section may have multiple owner names
 224         because of aliases.  The AA bit corresponds to the name which matches
 225         the query name, or the first owner name in the answer section.
 226 TC      TrunCation - this message was truncated.
 227 RD      Recursion Desired - this bit may be set in a query and
 228         is copied into the response.  If RD is set, it directs
 229         the name server to pursue the query recursively.
 230         Recursive query support is optional.
 231 RA      Recursion Available - this be is set or cleared in a
 232         response, and denotes whether recursive query support is
 233         available in the name server.
 234 RCODE   Response code.
 235         0   No error condition
 236         1   Format error
 237         2   Server failure - server was unable to process the query
 238             due to a problem with the name server.
 239         3   Name Error - meaningful only for responses from
 240             an authoritative name server. The referenced domain name
 241             does not exist.
 242         4   Not Implemented.
 243         5   Refused.
 244 QDCOUNT number of entries in the question section.
 245 ANCOUNT number of records in the answer section.
 246 NSCOUNT number of records in the authority records section.
 247 ARCOUNT number of records in the additional records section.
 248
 249 4.1.2. Question section format
 250
 251 The section contains QDCOUNT (usually 1) entries, each of this format:
 252       0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
 253     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 254     /                     QNAME                     /
 255     /                                               /
 256     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 257     |                     QTYPE                     |
 258     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 259     |                     QCLASS                    |
 260     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 261 QNAME   a domain name represented as a sequence of labels, where
 262         each label consists of a length octet followed by that
 263         number of octets. The domain name terminates with the
 264         zero length octet for the null label of the root. Note
 265         that this field may be an odd number of octets; no
 266         padding is used.
 267 QTYPE   a two octet type of the query.
 268           1 a host address [REQ_A const]
 269           2 an authoritative name server
 270           3 a mail destination (Obsolete - use MX)
 271           4 a mail forwarder (Obsolete - use MX)
 272           5 the canonical name for an alias
 273           6 marks the start of a zone of authority
 274           7 a mailbox domain name (EXPERIMENTAL)
 275           8 a mail group member (EXPERIMENTAL)
 276           9 a mail rename domain name (EXPERIMENTAL)
 277          10 a null RR (EXPERIMENTAL)
 278          11 a well known service description
 279          12 a domain name pointer [REQ_PTR const]
 280          13 host information
 281          14 mailbox or mail list information
 282          15 mail exchange
 283          16 text strings
 284        0x1c IPv6?
 285         252 a request for a transfer of an entire zone
 286         253 a request for mailbox-related records (MB, MG or MR)
 287         254 a request for mail agent RRs (Obsolete - see MX)
 288         255 a request for all records
 289 QCLASS  a two octet code that specifies the class of the query.
 290           1 the Internet
 291         (others are historic only)
 292         255 any class
 293
 294 4.1.3. Resource Record format
 295
 296 The answer, authority, and additional sections all share the same format:
 297 a variable number of resource records, where the number of records
 298 is specified in the corresponding count field in the header.
 299 Each resource record has this format:
 300       0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
 301     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 302     /                                               /
 303     /                      NAME                     /
 304     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 305     |                      TYPE                     |
 306     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 307     |                     CLASS                     |
 308     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 309     |                      TTL                      |
 310     |                                               |
 311     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 312     |                   RDLENGTH                    |
 313     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--|
 314     /                     RDATA                     /
 315     /                                               /
 316     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 317 NAME    a domain name to which this resource record pertains.
 318 TYPE    two octets containing one of the RR type codes.  This
 319         field specifies the meaning of the data in the RDATA field.
 320 CLASS   two octets which specify the class of the data in the RDATA field.
 321 TTL     a 32 bit unsigned integer that specifies the time interval
 322         (in seconds) that the record may be cached.
 323 RDLENGTH a 16 bit integer, length in octets of the RDATA field.
 324 RDATA   a variable length string of octets that describes the resource.
 325         The format of this information varies according to the TYPE
 326         and CLASS of the resource record.
 327         If the TYPE is A and the CLASS is IN, it's a 4 octet IP address.
 328
 329 4.1.4. Message compression
 330
 331 In order to reduce the size of messages, domain names coan be compressed.
 332 An entire domain name or a list of labels at the end of a domain name
 333 is replaced with a pointer to a prior occurance of the same name.
 334
 335 The pointer takes the form of a two octet sequence:
 336     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 337     | 1  1|                OFFSET                   |
 338     +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
 339 The first two bits are ones.  This allows a pointer to be distinguished
 340 from a label, since the label must begin with two zero bits because
 341 labels are restricted to 63 octets or less.  The OFFSET field specifies
 342 an offset from the start of the message (i.e., the first octet
 343 of the ID field in the domain header).
 344 A zero offset specifies the first byte of the ID field, etc.
 345 Domain name in a message can be represented as either:
 346    - a sequence of labels ending in a zero octet
 347    - a pointer
 348    - a sequence of labels ending with a pointer
 349  */
 350 static int process_packet(struct dns_entry *conf_data,
 351                 uint32_t conf_ttl,
 352                 uint8_t *buf)
 353 {
 354         char *answstr;
 355         struct dns_head *head;
 356         struct type_and_class *unaligned_type_class;
 357         char *query_string;
 358         uint8_t *answb;
 359         uint16_t outr_rlen;
 360         uint16_t outr_flags;
 361         uint16_t type;
 362         uint16_t class;
 363         int query_len;
 364
 365         head = (struct dns_head *)buf;
 366         if (head->nquer == 0) {
 367                 bb_error_msg("packet has 0 queries, ignored");
 368                 return -1;
 369         }
 370
 371         if (head->flags & htons(0x8000)) { /* QR bit */
 372                 bb_error_msg("response packet, ignored");
 373                 return -1;
 374         }
 375
 376         /* start of query string */
 377         query_string = (void *)(head + 1);
 378         /* caller guarantees strlen is <= MAX_PACK_LEN */
 379         query_len = strlen(query_string) + 1;
 380         /* may be unaligned! */
 381         unaligned_type_class = (void *)(query_string + query_len);
 382         query_len += sizeof(unaligned_type_class);
 383         /* where to append answer block */
 384         answb = (void *)(unaligned_type_class + 1);
 385
 386         /* QR = 1 "response", RCODE = 4 "Not Implemented" */
 387         outr_flags = htons(0x8000 | 4);
 388
 389         move_from_unaligned16(type, &unaligned_type_class->type);
 390         if (type != htons(REQ_A) && type != htons(REQ_PTR)) {
 391                 /* we can't handle the query type */
 392                 goto empty_packet;
 393         }
 394         move_from_unaligned16(class, &unaligned_type_class->class);
 395         if (class != htons(1)) { /* not class INET? */
 396                 goto empty_packet;
 397         }
 398         /* OPCODE != 0 "standard query" ? */
 399         if ((head->flags & htons(0x7800)) != 0) {
 400                 goto empty_packet;
 401         }
 402
 403         /* look up the name */
 404 #if DEBUG
 405         /* need to convert lengths to dots before we can use it in non-debug */
 406         bb_info_msg("%s", query_string);
 407 #endif
 408         answstr = table_lookup(conf_data, type, query_string);
 409         outr_rlen = 4;
 410         if (answstr && type == htons(REQ_PTR)) {
 411                 /* returning a host name */
 412                 outr_rlen = strlen(answstr) + 1;
 413         }
 414         if (!answstr
 415          || (unsigned)(answb - buf) + query_len + 4 + 2 + outr_rlen > MAX_PACK_LEN
 416         ) {
 417                 /* QR = 1 "response"
 418                  * AA = 1 "Authoritative Answer"
 419                  * RCODE = 3 "Name Error" */
 420                 outr_flags = htons(0x8000 | 0x0400 | 3);
 421                 goto empty_packet;
 422         }
 423
 424         /* Append answer Resource Record */
 425         memcpy(answb, query_string, query_len); /* name, type, class */
 426         answb += query_len;
 427         move_to_unaligned32((uint32_t *)answb, htonl(conf_ttl));
 428         answb += 4;
 429         move_to_unaligned16((uint16_t *)answb, htons(outr_rlen));
 430         answb += 2;
 431         memcpy(answb, answstr, outr_rlen);
 432         answb += outr_rlen;
 433
 434         /* QR = 1 "response",
 435          * AA = 1 "Authoritative Answer",
 436          * TODO: need to set RA bit 0x80? One user says nslookup complains
 437          * "Got recursion not available from SERVER, trying next server"
 438          * "** server can't find HOSTNAME"
 439          * RCODE = 0 "success"
 440          */
 441         outr_flags = htons(0x8000 | 0x0400 | 0);
 442         /* we have one answer */
 443         head->nansw = htons(1);
 444
 445  empty_packet:
 446         head->flags |= outr_flags;
 447         head->nauth = head->nadd = 0;
 448         head->nquer = htons(1); // why???
 449
 450         return answb - buf;
 451 }
 452
 453 int dnsd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 454 int dnsd_main(int argc UNUSED_PARAM, char **argv)
 455 {
 456         const char *listen_interface = "0.0.0.0";
 457         const char *fileconf = "/etc/dnsd.conf";
 458         struct dns_entry *conf_data;
 459         uint32_t conf_ttl = DEFAULT_TTL;
 460         char *sttl, *sport;
 461         len_and_sockaddr *lsa, *from, *to;
 462         unsigned lsa_size;
 463         int udps, opts;
 464         uint16_t port = 53;
 465         uint8_t buf[MAX_PACK_LEN + 1];
 466
 467         opts = getopt32(argv, "vi:c:t:p:d", &listen_interface, &fileconf, &sttl, &sport);
 468         //if (opts & 0x1) // -v
 469         //if (opts & 0x2) // -i
 470         //if (opts & 0x4) // -c
 471         if (opts & 0x8) // -t
 472                 conf_ttl = xatou_range(sttl, 1, 0xffffffff);
 473         if (opts & 0x10) // -p
 474                 port = xatou_range(sport, 1, 0xffff);
 475         if (opts & 0x20) { // -d
 476                 bb_daemonize_or_rexec(DAEMON_CLOSE_EXTRA_FDS, argv);
 477                 openlog(applet_name, LOG_PID, LOG_DAEMON);
 478                 logmode = LOGMODE_SYSLOG;
 479         }
 480         /* Clear all except "verbose" bit */
 481         option_mask32 &= 1;
 482
 483         conf_data = parse_conf_file(fileconf);
 484
 485         lsa = xdotted2sockaddr(listen_interface, port);
 486         udps = xsocket(lsa->u.sa.sa_family, SOCK_DGRAM, 0);
 487         xbind(udps, &lsa->u.sa, lsa->len);
 488         socket_want_pktinfo(udps); /* needed for recv_from_to to work */
 489         lsa_size = LSA_LEN_SIZE + lsa->len;
 490         from = xzalloc(lsa_size);
 491         to = xzalloc(lsa_size);
 492
 493         {
 494                 char *p = xmalloc_sockaddr2dotted(&lsa->u.sa);
 495                 bb_info_msg("Accepting UDP packets on %s", p);
 496                 free(p);
 497         }
 498
 499         while (1) {
 500                 int r;
 501                 /* Try to get *DEST* address (to which of our addresses
 502                  * this query was directed), and reply from the same address.
 503                  * Or else we can exhibit usual UDP ugliness:
 504                  * [ip1.multihomed.ip2] <=  query to ip1  <= peer
 505                  * [ip1.multihomed.ip2] => reply from ip2 => peer (confused) */
 506                 memcpy(to, lsa, lsa_size);
 507                 r = recv_from_to(udps, buf, MAX_PACK_LEN + 1, 0, &from->u.sa, &to->u.sa, lsa->len);
 508                 if (r < 12 || r > MAX_PACK_LEN) {
 509                         bb_error_msg("packet size %d, ignored", r);
 510                         continue;
 511                 }
 512                 if (OPT_verbose)
 513                         bb_info_msg("Got UDP packet");
 514                 buf[r] = '\0'; /* paranoia */
 515                 r = process_packet(conf_data, conf_ttl, buf);
 516                 if (r <= 0)
 517                         continue;
 518                 send_to_from(udps, buf, r, 0, &from->u.sa, &to->u.sa, lsa->len);
 519         }
 520         return 0;
 521 }