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 this query type */
 392 //TODO: handle REQ_AAAA (0x1c) requests
 393                 bb_error_msg("type %u is !REQ_A and !REQ_PTR%s",
 394                                 (int)ntohs(type),
 395                                 ", returning Not Implemented reply");
 396                 goto empty_packet;
 397         }
 398         move_from_unaligned16(class, &unaligned_type_class->class);
 399         if (class != htons(1)) { /* not class INET? */
 400                 bb_error_msg("class != 1%s",
 401                                 ", returning Not Implemented reply");
 402                 goto empty_packet;
 403         }
 404         /* OPCODE != 0 "standard query" ? */
 405         if ((head->flags & htons(0x7800)) != 0) {
 406                 bb_error_msg("opcode != 0%s",
 407                                 ", returning Not Implemented reply");
 408                 goto empty_packet;
 409         }
 410
 411         /* look up the name */
 412         answstr = table_lookup(conf_data, type, query_string);
 413 #if DEBUG
 414         /* Shows lengths instead of dots, unusable for !DEBUG */
 415         bb_error_msg("'%s'->'%s'", query_string, answstr);
 416 #endif
 417         outr_rlen = 4;
 418         if (answstr && type == htons(REQ_PTR)) {
 419                 /* returning a host name */
 420                 outr_rlen = strlen(answstr) + 1;
 421         }
 422         if (!answstr
 423          || (unsigned)(answb - buf) + query_len + 4 + 2 + outr_rlen > MAX_PACK_LEN
 424         ) {
 425                 /* QR = 1 "response"
 426                  * AA = 1 "Authoritative Answer"
 427                  * RCODE = 3 "Name Error" */
 428                 if (OPT_verbose)
 429                         bb_error_msg("returning Name Error reply");
 430                 outr_flags = htons(0x8000 | 0x0400 | 3);
 431                 goto empty_packet;
 432         }
 433
 434         /* Append answer Resource Record */
 435         memcpy(answb, query_string, query_len); /* name, type, class */
 436         answb += query_len;
 437         move_to_unaligned32((uint32_t *)answb, htonl(conf_ttl));
 438         answb += 4;
 439         move_to_unaligned16((uint16_t *)answb, htons(outr_rlen));
 440         answb += 2;
 441         memcpy(answb, answstr, outr_rlen);
 442         answb += outr_rlen;
 443
 444         /* QR = 1 "response",
 445          * AA = 1 "Authoritative Answer",
 446          * TODO: need to set RA bit 0x80? One user says nslookup complains
 447          * "Got recursion not available from SERVER, trying next server"
 448          * "** server can't find HOSTNAME"
 449          * RCODE = 0 "success"
 450          */
 451         if (OPT_verbose)
 452                 bb_error_msg("returning positive reply");
 453         outr_flags = htons(0x8000 | 0x0400 | 0);
 454         /* we have one answer */
 455         head->nansw = htons(1);
 456
 457  empty_packet:
 458         head->flags |= outr_flags;
 459         head->nauth = head->nadd = 0;
 460         head->nquer = htons(1); // why???
 461
 462         return answb - buf;
 463 }
 464
 465 int dnsd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 466 int dnsd_main(int argc UNUSED_PARAM, char **argv)
 467 {
 468         const char *listen_interface = "0.0.0.0";
 469         const char *fileconf = "/etc/dnsd.conf";
 470         struct dns_entry *conf_data;
 471         uint32_t conf_ttl = DEFAULT_TTL;
 472         char *sttl, *sport;
 473         len_and_sockaddr *lsa, *from, *to;
 474         unsigned lsa_size;
 475         int udps, opts;
 476         uint16_t port = 53;
 477         uint8_t buf[MAX_PACK_LEN + 1];
 478
 479         opts = getopt32(argv, "vi:c:t:p:d", &listen_interface, &fileconf, &sttl, &sport);
 480         //if (opts & 0x1) // -v
 481         //if (opts & 0x2) // -i
 482         //if (opts & 0x4) // -c
 483         if (opts & 0x8) // -t
 484                 conf_ttl = xatou_range(sttl, 1, 0xffffffff);
 485         if (opts & 0x10) // -p
 486                 port = xatou_range(sport, 1, 0xffff);
 487         if (opts & 0x20) { // -d
 488                 bb_daemonize_or_rexec(DAEMON_CLOSE_EXTRA_FDS, argv);
 489                 openlog(applet_name, LOG_PID, LOG_DAEMON);
 490                 logmode = LOGMODE_SYSLOG;
 491         }
 492         /* Clear all except "verbose" bit */
 493         option_mask32 &= 1;
 494
 495         conf_data = parse_conf_file(fileconf);
 496
 497         lsa = xdotted2sockaddr(listen_interface, port);
 498         udps = xsocket(lsa->u.sa.sa_family, SOCK_DGRAM, 0);
 499         xbind(udps, &lsa->u.sa, lsa->len);
 500         socket_want_pktinfo(udps); /* needed for recv_from_to to work */
 501         lsa_size = LSA_LEN_SIZE + lsa->len;
 502         from = xzalloc(lsa_size);
 503         to = xzalloc(lsa_size);
 504
 505         {
 506                 char *p = xmalloc_sockaddr2dotted(&lsa->u.sa);
 507                 bb_error_msg("accepting UDP packets on %s", p);
 508                 free(p);
 509         }
 510
 511         while (1) {
 512                 int r;
 513                 /* Try to get *DEST* address (to which of our addresses
 514                  * this query was directed), and reply from the same address.
 515                  * Or else we can exhibit usual UDP ugliness:
 516                  * [ip1.multihomed.ip2] <=  query to ip1  <= peer
 517                  * [ip1.multihomed.ip2] => reply from ip2 => peer (confused) */
 518                 memcpy(to, lsa, lsa_size);
 519                 r = recv_from_to(udps, buf, MAX_PACK_LEN + 1, 0, &from->u.sa, &to->u.sa, lsa->len);
 520                 if (r < 12 || r > MAX_PACK_LEN) {
 521                         bb_error_msg("packet size %d, ignored", r);
 522                         continue;
 523                 }
 524                 if (OPT_verbose)
 525                         bb_error_msg("got UDP packet");
 526                 buf[r] = '\0'; /* paranoia */
 527                 r = process_packet(conf_data, conf_ttl, buf);
 528                 if (r <= 0)
 529                         continue;
 530                 send_to_from(udps, buf, r, 0, &from->u.sa, &to->u.sa, lsa->len);
 531         }
 532         return 0;
 533 }