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