CVSing the test suite.
[exim.git] / test / src / fakens.c
1 /* $Cambridge: exim/test/src/fakens.c,v 1.1 2006/02/06 16:24:05 ph10 Exp $ */
2
3 /*************************************************
4 * fakens - A Fake Nameserver Program *
5 *************************************************/
6
7 /* This program exists to support the testing of DNS handling code in Exim. It
8 avoids the need to install special zones in a real nameserver. When Exim is
9 running in its (new) test harness, DNS lookups are first passed to this program
10 instead of to the real resolver. (With a few exceptions - see the discussion in
11 the test suite's README file.) The program is also passed the name of the Exim
12 spool directory; it expects to find its "zone files" in ../dnszones relative to
13 that directory. Note that there is little checking in this program. The fake
14 zone files are assumed to be syntactically valid.
15
16 The zones that are handled are found by scanning the dnszones directory. A file
17 whose name is of the form db.ip4.x is a zone file for .x.in-addr.arpa; a file
18 whose name is of the form db.ip6.x is a zone file for .x.ip6.arpa; a file of
19 the form db.anything.else is a zone file for .anything.else. A file of the form
20 qualify.x.y specifies the domain that is used to qualify single-component
21 names, except for the name "dontqualify".
22
23 The arguments to the program are:
24
25 the name of the Exim spool directory
26 the domain name that is being sought
27 the DNS record type that is being sought
28
29 The output from the program is written to stdout. It is supposed to be in
30 exactly the same format as a traditional namserver response (see RFC 1035) so
31 that Exim can process it as normal. At present, no compression is used.
32 Error messages are written to stderr.
33
34 The return codes from the program are zero for success, and otherwise the
35 values that are set in h_errno after a failing call to the normal resolver:
36
37 1 HOST_NOT_FOUND host not found (authoritative)
38 2 TRY_AGAIN server failure
39 3 NO_RECOVERY non-recoverable error
40 4 NO_DATA valid name, no data of requested type
41
42 In a real nameserver, TRY_AGAIN is also used for a non-authoritative not found,
43 but it is not used for that here. There is also one extra return code:
44
45 5 PASS_ON requests Exim to call res_search()
46
47 This is used for zones that fakens does not recognize. It is also used if a
48 line in the zone file contains exactly this:
49
50 PASS ON NOT FOUND
51
52 and the domain is not found. It converts the the result to PASS_ON instead of
53 HOST_NOT_FOUND. */
54
55 #include <ctype.h>
56 #include <stdarg.h>
57 #include <stdio.h>
58 #include <string.h>
59 #include <netdb.h>
60 #include <errno.h>
61 #include <arpa/nameser.h>
62 #include <sys/types.h>
63 #include <dirent.h>
64
65 #define FALSE 0
66 #define TRUE 1
67 #define PASS_ON 5
68
69 typedef int BOOL;
70 typedef unsigned char uschar;
71
72 #define CS (char *)
73 #define CCS (const char *)
74 #define US (unsigned char *)
75
76 #define Ustrcat(s,t) strcat(CS(s),CCS(t))
77 #define Ustrchr(s,n) US strchr(CCS(s),n)
78 #define Ustrcmp(s,t) strcmp(CCS(s),CCS(t))
79 #define Ustrcpy(s,t) strcpy(CS(s),CCS(t))
80 #define Ustrlen(s) (int)strlen(CCS(s))
81 #define Ustrncmp(s,t,n) strncmp(CCS(s),CCS(t),n)
82 #define Ustrncpy(s,t,n) strncpy(CS(s),CCS(t),n)
83
84
85 typedef struct adomainstr {
86 struct adomainstr *next;
87 uschar name[1];
88 } adomainstr;
89
90 typedef struct zoneitem {
91 uschar *zone;
92 uschar *zonefile;
93 } zoneitem;
94
95 typedef struct tlist {
96 uschar *name;
97 int value;
98 } tlist;
99
100 /* On some (older?) operating systems, the standard ns_t_xxx definitions are
101 not available, and only the older T_xxx ones exist in nameser.h. If ns_t_a is
102 not defined, assume we are in this state. A really old system might not even
103 know about AAAA and SRV at all. */
104
105 #ifndef ns_t_a
106 #define ns_t_a T_A
107 #define ns_t_ns T_NS
108 #define ns_t_cname T_CNAME
109 #define ns_t_soa T_SOA
110 #define ns_t_ptr T_PTR
111 #define ns_t_mx T_MX
112 #define ns_t_txt T_TXT
113 #define ns_t_aaaa T_AAAA
114 #define ns_t_srv T_SRV
115 #ifndef T_AAAA
116 #define T_AAAA 28
117 #endif
118 #ifndef T_SRV
119 #define T_SRV 33
120 #endif
121 #endif
122
123 static tlist type_list[] = {
124 { US"A", ns_t_a },
125 { US"NS", ns_t_ns },
126 { US"CNAME", ns_t_cname },
127 /* { US"SOA", ns_t_soa }, Not currently in use */
128 { US"PTR", ns_t_ptr },
129 { US"MX", ns_t_mx },
130 { US"TXT", ns_t_txt },
131 { US"AAAA", ns_t_aaaa },
132 { US"SRV", ns_t_srv },
133 { NULL, 0 }
134 };
135
136
137
138 /*************************************************
139 * Get memory and sprintf into it *
140 *************************************************/
141
142 /* This is used when building a table of zones and their files.
143
144 Arguments:
145 format a format string
146 ... arguments
147
148 Returns: pointer to formatted string
149 */
150
151 static uschar *
152 fcopystring(uschar *format, ...)
153 {
154 uschar *yield;
155 char buffer[256];
156 va_list ap;
157 va_start(ap, format);
158 vsprintf(buffer, format, ap);
159 va_end(ap);
160 yield = (uschar *)malloc(Ustrlen(buffer) + 1);
161 Ustrcpy(yield, buffer);
162 return yield;
163 }
164
165
166 /*************************************************
167 * Pack name into memory *
168 *************************************************/
169
170 /* This function packs a domain name into memory according to DNS rules. At
171 present, it doesn't do any compression.
172
173 Arguments:
174 name the name
175 pk where to put it
176
177 Returns: the updated value of pk
178 */
179
180 static uschar *
181 packname(uschar *name, uschar *pk)
182 {
183 while (*name != 0)
184 {
185 uschar *p = name;
186 while (*p != 0 && *p != '.') p++;
187 *pk++ = (p - name);
188 memmove(pk, name, p - name);
189 pk += p - name;
190 name = (*p == 0)? p : p + 1;
191 }
192 *pk++ = 0;
193 return pk;
194 }
195
196
197
198 /*************************************************
199 * Scan file for RRs *
200 *************************************************/
201
202 /* This function scans an open "zone file" for appropriate records, and adds
203 any that are found to the output buffer.
204
205 Arguments:
206 f the input FILE
207 zone the current zone name
208 domain the domain we are looking for
209 qtype the type of RR we want
210 qtypelen the length of qtype
211 pkptr points to the output buffer pointer; this is updated
212 countptr points to the record count; this is updated
213 adomainptr points to where to hang additional domains
214
215 Returns: 0 on success, else HOST_NOT_FOUND or NO_DATA or NO_RECOVERY or
216 PASS_ON - the latter if a "PASS ON NOT FOUND" line is seen
217 */
218
219 static int
220 find_records(FILE *f, uschar *zone, uschar *domain, uschar *qtype,
221 int qtypelen, uschar **pkptr, int *countptr, adomainstr **adomainptr)
222 {
223 int yield = HOST_NOT_FOUND;
224 int zonelen = Ustrlen(zone);
225 int domainlen = Ustrlen(domain);
226 BOOL pass_on_not_found = FALSE;
227 tlist *typeptr;
228 uschar *pk = *pkptr;
229 uschar buffer[256];
230 uschar rrdomain[256];
231
232 /* Decode the required type */
233
234 for (typeptr = type_list; typeptr->name != NULL; typeptr++)
235 { if (Ustrcmp(typeptr->name, qtype) == 0) break; }
236 if (typeptr->name == NULL)
237 {
238 fprintf(stderr, "fakens: unknown record type %s\n", qtype);
239 return NO_RECOVERY;
240 }
241
242 rrdomain[0] = 0; /* No previous domain */
243 (void)fseek(f, 0, SEEK_SET); /* Start again at the beginning */
244
245 /* Scan for RRs */
246
247 while (fgets(CS buffer, sizeof(buffer), f) != NULL)
248 {
249 uschar *rdlptr;
250 uschar *p, *ep, *pp;
251 BOOL found_cname = FALSE;
252 int i, plen, value;
253 int tvalue = typeptr->value;
254 int qtlen = qtypelen;
255
256 p = buffer;
257 while (isspace(*p)) p++;
258 if (*p == 0 || *p == ';') continue;
259
260 if (Ustrncmp(p, "PASS ON NOT FOUND", 17) == 0)
261 {
262 pass_on_not_found = TRUE;
263 continue;
264 }
265
266 ep = buffer + Ustrlen(buffer);
267 while (isspace(ep[-1])) ep--;
268 *ep = 0;
269
270 p = buffer;
271 if (!isspace(*p))
272 {
273 uschar *pp = rrdomain;
274 while (!isspace(*p)) *pp++ = tolower(*p++);
275 if (pp[-1] != '.') Ustrcpy(pp, zone); else pp[-1] = 0;
276 }
277
278 /* Compare domain names; first check for a wildcard */
279
280 if (rrdomain[0] == '*')
281 {
282 int restlen = Ustrlen(rrdomain) - 1;
283 if (domainlen > restlen &&
284 Ustrcmp(domain + domainlen - restlen, rrdomain + 1) != 0) continue;
285 }
286
287 /* Not a wildcard RR */
288
289 else if (Ustrcmp(domain, rrdomain) != 0) continue;
290
291 /* The domain matches */
292
293 if (yield == HOST_NOT_FOUND) yield = NO_DATA;
294
295 /* Compare RR types; a CNAME record is always returned */
296
297 while (isspace(*p)) p++;
298
299 if (Ustrncmp(p, "CNAME", 5) == 0)
300 {
301 tvalue = ns_t_cname;
302 qtlen = 5;
303 found_cname = TRUE;
304 }
305 else if (Ustrncmp(p, qtype, qtypelen) != 0 || !isspace(p[qtypelen])) continue;
306
307 /* Found a relevant record */
308
309 yield = 0;
310 *countptr = *countptr + 1;
311
312 p += qtlen;
313 while (isspace(*p)) p++;
314
315 pk = packname(domain, pk); /* Not rrdomain because of wildcard */
316 *pk++ = (tvalue >> 8) & 255;
317 *pk++ = (tvalue) & 255;
318 *pk++ = 0;
319 *pk++ = 1; /* class = IN */
320
321 pk += 4; /* TTL field; don't care */
322
323 rdlptr = pk; /* remember rdlength field */
324 pk += 2;
325
326 /* The rest of the data depends on the type */
327
328 switch (tvalue)
329 {
330 case ns_t_soa: /* Not currently used */
331 break;
332
333 case ns_t_a:
334 for (i = 0; i < 4; i++)
335 {
336 value = 0;
337 while (isdigit(*p)) value = value*10 + *p++ - '0';
338 *pk++ = value;
339 p++;
340 }
341 break;
342
343 /* The only occurrence of a double colon is for ::1 */
344 case ns_t_aaaa:
345 if (Ustrcmp(p, "::1") == 0)
346 {
347 memset(pk, 0, 15);
348 pk += 15;
349 *pk++ = 1;
350 }
351 else for (i = 0; i < 8; i++)
352 {
353 value = 0;
354 while (isxdigit(*p))
355 {
356 value = value * 16 + toupper(*p) - (isdigit(*p)? '0' : '7');
357 p++;
358 }
359 *pk++ = (value >> 8) & 255;
360 *pk++ = value & 255;
361 p++;
362 }
363 break;
364
365 case ns_t_mx:
366 value = 0;
367 while (isdigit(*p)) value = value*10 + *p++ - '0';
368 while (isspace(*p)) p++;
369 *pk++ = (value >> 8) & 255;
370 *pk++ = value & 255;
371 goto PACKNAME;
372
373 case ns_t_txt:
374 pp = pk++;
375 if (*p == '"') p++; /* Should always be the case */
376 while (*p != 0 && *p != '"') *pk++ = *p++;
377 *pp = pk - pp - 1;
378 break;
379
380 case ns_t_srv:
381 for (i = 0; i < 3; i++)
382 {
383 value = 0;
384 while (isdigit(*p)) value = value*10 + *p++ - '0';
385 while (isspace(*p)) p++;
386 *pk++ = (value >> 8) & 255;
387 *pk++ = value & 255;
388 }
389
390 /* Fall through */
391
392 case ns_t_cname:
393 case ns_t_ns:
394 case ns_t_ptr:
395 PACKNAME:
396 if (ep[-1] != '.') sprintf(ep, "%s.", zone);
397 pk = packname(p, pk);
398 plen = Ustrlen(p);
399 if (adomainptr != NULL && plen > zonelen + 2 &&
400 Ustrncmp(p + plen - zonelen - 1, zone, zonelen) == 0)
401 {
402 adomainstr *adomain = (adomainstr *)malloc(sizeof(adomainstr) + plen);
403 *adomainptr = adomain;
404 adomainptr = &(adomain->next);
405 adomain->next = NULL;
406 Ustrncpy(adomain->name, p, plen - 1);
407 adomain->name[plen-1] = 0;
408 }
409 break;
410 }
411
412 /* Fill in the length, and we are done with this RR */
413
414 rdlptr[0] = ((pk - rdlptr - 2) >> 8) & 255;
415 rdlptr[1] = (pk -rdlptr - 2) & 255;
416
417 /* If we have just yielded a CNAME, we must change the domain name to the
418 new domain, and re-start the scan from the beginning. */
419
420 if (found_cname)
421 {
422 domain = fcopystring("%s", p);
423 domainlen = Ustrlen(domain);
424 domain[domainlen - 1] = 0; /* Removed trailing dot */
425 rrdomain[0] = 0; /* No previous domain */
426 (void)fseek(f, 0, SEEK_SET); /* Start again at the beginning */
427 }
428 }
429
430 *pkptr = pk;
431 return (yield == HOST_NOT_FOUND && pass_on_not_found)? PASS_ON : yield;
432 }
433
434
435
436 /*************************************************
437 * Entry point and main program *
438 *************************************************/
439
440 int
441 main(int argc, char **argv)
442 {
443 FILE *f;
444 DIR *d;
445 int dirlen, domlen, qtypelen;
446 int yield, count;
447 int i;
448 int zonecount = 0;
449 tlist *typeptr;
450 struct dirent *de;
451 adomainstr *adomain = NULL;
452 zoneitem zones[32];
453 uschar *qualify = NULL;
454 uschar *p, *zone;
455 uschar *zonefile = NULL;
456 uschar domain[256];
457 uschar buffer[256];
458 uschar qtype[12];
459 uschar packet[512];
460 uschar *pk = packet;
461
462 if (argc != 4)
463 {
464 fprintf(stderr, "fakens: expected 3 arguments, received %d\n", argc-1);
465 return NO_RECOVERY;
466 }
467
468 /* Find the zones */
469
470 (void)sprintf(buffer, "%s/../dnszones", argv[1]);
471
472 d = opendir(CCS buffer);
473 if (d == NULL)
474 {
475 fprintf(stderr, "fakens: failed to opendir %s: %s\n", buffer,
476 strerror(errno));
477 return NO_RECOVERY;
478 }
479
480 while ((de = readdir(d)) != NULL)
481 {
482 uschar *name = de->d_name;
483 if (Ustrncmp(name, "qualify.", 8) == 0)
484 {
485 qualify = fcopystring("%s", name + 7);
486 continue;
487 }
488 if (Ustrncmp(name, "db.", 3) != 0) continue;
489 if (Ustrncmp(name + 3, "ip4.", 4) == 0)
490 zones[zonecount].zone = fcopystring("%s.in-addr.arpa", name + 6);
491 else if (Ustrncmp(name + 3, "ip6.", 4) == 0)
492 zones[zonecount].zone = fcopystring("%s.ip6.arpa", name + 6);
493 else
494 zones[zonecount].zone = fcopystring("%s", name + 2);
495 zones[zonecount++].zonefile = fcopystring("%s", name);
496 }
497 (void)closedir(d);
498
499 /* Get the RR type and upper case it, and check that we recognize it. */
500
501 Ustrncpy(qtype, argv[3], sizeof(qtype));
502 qtypelen = Ustrlen(qtype);
503 for (p = qtype; *p != 0; p++) *p = toupper(*p);
504
505 /* Find the domain, lower case it, check that it is in a zone that we handle,
506 and set up the zone file name. The zone names in the table all start with a
507 dot. */
508
509 domlen = Ustrlen(argv[2]);
510 if (argv[2][domlen-1] == '.') domlen--;
511 Ustrncpy(domain, argv[2], domlen);
512 domain[domlen] = 0;
513 for (i = 0; i < domlen; i++) domain[i] = tolower(domain[i]);
514
515 if (Ustrchr(domain, '.') == NULL && qualify != NULL &&
516 Ustrcmp(domain, "dontqualify") != 0)
517 {
518 Ustrcat(domain, qualify);
519 domlen += Ustrlen(qualify);
520 }
521
522 for (i = 0; i < zonecount; i++)
523 {
524 int zlen;
525 zone = zones[i].zone;
526 zlen = Ustrlen(zone);
527 if (Ustrcmp(domain, zone+1) == 0 || (domlen >= zlen &&
528 Ustrcmp(domain + domlen - zlen, zone) == 0))
529 {
530 zonefile = zones[i].zonefile;
531 break;
532 }
533 }
534
535 if (zonefile == NULL)
536 {
537 fprintf(stderr, "fakens: query not in faked zone: domain is: %s\n", domain);
538 return PASS_ON;
539 }
540
541 (void)sprintf(buffer, "%s/../dnszones/%s", argv[1], zonefile);
542
543 /* Initialize the start of the response packet. We don't have to fake up
544 everything, because we know that Exim will look only at the answer and
545 additional section parts. */
546
547 memset(packet, 0, 12);
548 pk += 12;
549
550 /* Open the zone file. */
551
552 f = fopen(buffer, "r");
553 if (f == NULL)
554 {
555 fprintf(stderr, "fakens: failed to open %s: %s\n", buffer, strerror(errno));
556 return NO_RECOVERY;
557 }
558
559 /* Find the records we want, and add them to the result. */
560
561 count = 0;
562 yield = find_records(f, zone, domain, qtype, qtypelen, &pk, &count, &adomain);
563 if (yield == NO_RECOVERY) goto END_OFF;
564
565 packet[6] = (count >> 8) & 255;
566 packet[7] = count & 255;
567
568 /* Search for additional records and add them to the result. */
569
570 count = 0;
571 for (; adomain != NULL; adomain = adomain->next)
572 {
573 (void)find_records(f, zone, adomain->name, US"AAAA", 4, &pk, &count, NULL);
574 (void)find_records(f, zone, adomain->name, US"A", 1, &pk, &count, NULL);
575 }
576
577 packet[10] = (count >> 8) & 255;
578 packet[11] = count & 255;
579
580 /* Close the zone file, write the result, and return. */
581
582 END_OFF:
583 (void)fclose(f);
584 (void)fwrite(packet, 1, pk - packet, stdout);
585 return yield;
586 }
587
588 /* End of fakens.c */