1/*
2 * Copyright (c) 1998 Sendmail, Inc. All rights reserved.
3 * Copyright (c) 1986, 1995-1997 Eric P. Allman. All rights reserved.
4 * Copyright (c) 1988, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * By using this file, you agree to the terms and conditions set
8 * forth in the LICENSE file which can be found at the top level of
9 * the sendmail distribution.
10 *
11 */
12
13#include "sendmail.h"
14
15#ifndef lint
16#if NAMED_BIND
17static char sccsid[] = "@(#)domain.c 8.80 (Berkeley) 12/17/1998 (with name server)";
18#else
19static char sccsid[] = "@(#)domain.c 8.80 (Berkeley) 12/17/1998 (without name server)";
20#endif
21#endif /* not lint */
22
23#if NAMED_BIND
24
25#include <errno.h>
26#include <resolv.h>
27#include <arpa/inet.h>
28
29/*
30** The standard udp packet size PACKETSZ (512) is not sufficient for some
31** nameserver answers containing very many resource records. The resolver
32** may switch to tcp and retry if it detects udp packet overflow.
33** Also note that the resolver routines res_query and res_search return
34** the size of the *un*truncated answer in case the supplied answer buffer
35** it not big enough to accommodate the entire answer.
36*/
37
38#ifndef MAXPACKET
39# define MAXPACKET 8192 /* max packet size used internally by BIND */
40#endif
41
42typedef union
43{
44 HEADER qb1;
45 u_char qb2[MAXPACKET];
46} querybuf;
47
48#ifndef MXHOSTBUFSIZE
49# define MXHOSTBUFSIZE (128 * MAXMXHOSTS)
50#endif
51
52static char MXHostBuf[MXHOSTBUFSIZE];
53
54#ifndef MAXDNSRCH
55# define MAXDNSRCH 6 /* number of possible domains to search */
56#endif
57
58#ifndef MAX
59# define MAX(a, b) ((a) > (b) ? (a) : (b))
60#endif
61
62#ifndef NO_DATA
63# define NO_DATA NO_ADDRESS
64#endif
65
66#ifndef HFIXEDSZ
67# define HFIXEDSZ 12 /* sizeof(HEADER) */
68#endif
69
70#define MAXCNAMEDEPTH 10 /* maximum depth of CNAME recursion */
71
72#if defined(__RES) && (__RES >= 19940415)
73# define RES_UNC_T char *
74#else
75# define RES_UNC_T u_char *
76#endif
77/*
78** GETMXRR -- get MX resource records for a domain
79**
80** Parameters:
81** host -- the name of the host to MX.
82** mxhosts -- a pointer to a return buffer of MX records.
83** droplocalhost -- If TRUE, all MX records less preferred
84** than the local host (as determined by $=w) will
85** be discarded.
86** rcode -- a pointer to an EX_ status code.
87**
88** Returns:
89** The number of MX records found.
90** -1 if there is an internal failure.
91** If no MX records are found, mxhosts[0] is set to host
92** and 1 is returned.
93*/
94
95int
96getmxrr(host, mxhosts, droplocalhost, rcode)
97 char *host;
98 char **mxhosts;
99 bool droplocalhost;
100 int *rcode;
101{
102 register u_char *eom, *cp;
103 register int i, j, n;
104 int nmx = 0;
105 register char *bp;
106 HEADER *hp;
107 querybuf answer;
108 int ancount, qdcount, buflen;
109 bool seenlocal = FALSE;
110 u_short pref, type;
111 u_short localpref = 256;
112 char *fallbackMX = FallBackMX;
113 bool trycanon = FALSE;
114 int (*resfunc)();
115 extern int res_query(), res_search();
116 u_short prefer[MAXMXHOSTS];
117 int weight[MAXMXHOSTS];
118 extern int mxrand __P((char *));
119
120 if (tTd(8, 2))
121 printf("getmxrr(%s, droplocalhost=%d)\n", host, droplocalhost);
122
123 if (fallbackMX != NULL && droplocalhost &&
124 wordinclass(fallbackMX, 'w'))
125 {
126 /* don't use fallback for this pass */
127 fallbackMX = NULL;
128 }
129
130 *rcode = EX_OK;
131
132 /* efficiency hack -- numeric or non-MX lookups */
133 if (host[0] == '[')
134 goto punt;
135
136 /*
137 ** If we don't have MX records in our host switch, don't
138 ** try for MX records. Note that this really isn't "right",
139 ** since we might be set up to try NIS first and then DNS;
140 ** if the host is found in NIS we really shouldn't be doing
141 ** MX lookups. However, that should be a degenerate case.
142 */
143
144 if (!UseNameServer)
145 goto punt;
146 if (HasWildcardMX && ConfigLevel >= 6)
147 resfunc = res_query;
148 else
149 resfunc = res_search;
150
151 errno = 0;
152 n = (*resfunc)(host, C_IN, T_MX, (u_char *) &answer, sizeof(answer));
153 if (n < 0)
154 {
155 if (tTd(8, 1))
156 printf("getmxrr: res_search(%s) failed (errno=%d, h_errno=%d)\n",
157 (host == NULL) ? "<NULL>" : host, errno, h_errno);
158 switch (h_errno)
159 {
160 case NO_DATA:
161 trycanon = TRUE;
162 /* fall through */
163
164 case NO_RECOVERY:
165 /* no MX data on this host */
166 goto punt;
167
168 case HOST_NOT_FOUND:
169#if BROKEN_RES_SEARCH
170 case 0: /* Ultrix resolver retns failure w/ h_errno=0 */
171#endif
172 /* host doesn't exist in DNS; might be in /etc/hosts */
173 trycanon = TRUE;
174 *rcode = EX_NOHOST;
175 goto punt;
176
177 case TRY_AGAIN:
178 case -1:
179 /* couldn't connect to the name server */
180 if (fallbackMX != NULL)
181 {
182 /* name server is hosed -- push to fallback */
183 mxhosts[nmx++] = fallbackMX;
184 return nmx;
185 }
186 /* it might come up later; better queue it up */
187 *rcode = EX_TEMPFAIL;
188 break;
189
190 default:
191 syserr("getmxrr: res_search (%s) failed with impossible h_errno (%d)\n",
192 host, h_errno);
193 *rcode = EX_OSERR;
194 break;
195 }
196
197 /* irreconcilable differences */
198 return (-1);
199 }
200
201 /* avoid problems after truncation in tcp packets */
202 if (n > sizeof(answer))
203 n = sizeof(answer);
204
205 /* find first satisfactory answer */
206 hp = (HEADER *)&answer;
207 cp = (u_char *)&answer + HFIXEDSZ;
208 eom = (u_char *)&answer + n;
209 for (qdcount = ntohs(hp->qdcount); qdcount--; cp += n + QFIXEDSZ)
210 if ((n = dn_skipname(cp, eom)) < 0)
211 goto punt;
212 buflen = sizeof(MXHostBuf) - 1;
213 bp = MXHostBuf;
214 ancount = ntohs(hp->ancount);
215 while (--ancount >= 0 && cp < eom && nmx < MAXMXHOSTS - 1)
216 {
217 if ((n = dn_expand((u_char *)&answer,
218 eom, cp, (RES_UNC_T) bp, buflen)) < 0)
219 break;
220 cp += n;
221 GETSHORT(type, cp);
222 cp += INT16SZ + INT32SZ;
223 GETSHORT(n, cp);
224 if (type != T_MX)
225 {
226 if (tTd(8, 8) || _res.options & RES_DEBUG)
227 printf("unexpected answer type %d, size %d\n",
228 type, n);
229 cp += n;
230 continue;
231 }
232 GETSHORT(pref, cp);
233 if ((n = dn_expand((u_char *)&answer, eom, cp,
234 (RES_UNC_T) bp, buflen)) < 0)
235 break;
236 cp += n;
237 if (wordinclass(bp, 'w'))
238 {
239 if (tTd(8, 3))
240 printf("found localhost (%s) in MX list, pref=%d\n",
241 bp, pref);
242 if (droplocalhost)
243 {
244 if (!seenlocal || pref < localpref)
245 localpref = pref;
246 seenlocal = TRUE;
247 continue;
248 }
249 weight[nmx] = 0;
250 }
251 else
252 weight[nmx] = mxrand(bp);
253 prefer[nmx] = pref;
254 mxhosts[nmx++] = bp;
255 n = strlen(bp);
256 bp += n;
257 if (bp[-1] != '.')
258 {
259 *bp++ = '.';
260 n++;
261 }
262 *bp++ = '\0';
263 buflen -= n + 1;
264 }
265
266 /* sort the records */
267 for (i = 0; i < nmx; i++)
268 {
269 for (j = i + 1; j < nmx; j++)
270 {
271 if (prefer[i] > prefer[j] ||
272 (prefer[i] == prefer[j] && weight[i] > weight[j]))
273 {
274 register int temp;
275 register char *temp1;
276
277 temp = prefer[i];
278 prefer[i] = prefer[j];
279 prefer[j] = temp;
280 temp1 = mxhosts[i];
281 mxhosts[i] = mxhosts[j];
282 mxhosts[j] = temp1;
283 temp = weight[i];
284 weight[i] = weight[j];
285 weight[j] = temp;
286 }
287 }
288 if (seenlocal && prefer[i] >= localpref)
289 {
290 /* truncate higher preference part of list */
291 nmx = i;
292 }
293 }
294
295 /* delete duplicates from list (yes, some bozos have duplicates) */
296 for (i = 0; i < nmx - 1; )
297 {
298 if (strcasecmp(mxhosts[i], mxhosts[i + 1]) != 0)
299 i++;
300 else
301 {
302 /* compress out duplicate */
303 for (j = i + 1; j < nmx; j++)
304 mxhosts[j] = mxhosts[j + 1];
305 nmx--;
306 }
307 }
308
309 if (nmx == 0)
310 {
311punt:
312 if (seenlocal &&
313 (!TryNullMXList || sm_gethostbyname(host) == NULL))
314 {
315 /*
316 ** If we have deleted all MX entries, this is
317 ** an error -- we should NEVER send to a host that
318 ** has an MX, and this should have been caught
319 ** earlier in the config file.
320 **
321 ** Some sites prefer to go ahead and try the
322 ** A record anyway; that case is handled by
323 ** setting TryNullMXList. I believe this is a
324 ** bad idea, but it's up to you....
325 */
326
327 *rcode = EX_CONFIG;
328 syserr("MX list for %s points back to %s",
329 host, MyHostName);
330 return -1;
331 }
332 if (strlen(host) >= (SIZE_T) sizeof MXHostBuf)
333 {
334 *rcode = EX_CONFIG;
335 syserr("Host name %s too long",
336 shortenstring(host, MAXSHORTSTR));
337 return -1;
338 }
339 snprintf(MXHostBuf, sizeof MXHostBuf, "%s", host);
340 mxhosts[0] = MXHostBuf;
341 if (host[0] == '[')
342 {
343 register char *p;
344
345 /* this may be an MX suppression-style address */
346 p = strchr(MXHostBuf, ']');
347 if (p != NULL)
348 {
349 *p = '\0';
350 if (inet_addr(&MXHostBuf[1]) != INADDR_NONE)
351 {
352 nmx++;
353 *p = ']';
354 }
355 else
356 {
357 trycanon = TRUE;
358 mxhosts[0]++;
359 }
360 }
361 }
362 if (trycanon &&
363 getcanonname(mxhosts[0], sizeof MXHostBuf - 2, FALSE))
364 {
365 bp = &MXHostBuf[strlen(MXHostBuf)];
366 if (bp[-1] != '.')
367 {
368 *bp++ = '.';
369 *bp = '\0';
370 }
371 nmx = 1;
372 }
373 }
374
375 /* if we have a default lowest preference, include that */
376 if (fallbackMX != NULL && !seenlocal)
377 mxhosts[nmx++] = fallbackMX;
378
379 return (nmx);
380}
381/*
382** MXRAND -- create a randomizer for equal MX preferences
383**
384** If two MX hosts have equal preferences we want to randomize
385** the selection. But in order for signatures to be the same,
386** we need to randomize the same way each time. This function
387** computes a pseudo-random hash function from the host name.
388**
389** Parameters:
390** host -- the name of the host.
391**
392** Returns:
393** A random but repeatable value based on the host name.
394**
395** Side Effects:
396** none.
397*/
398
399int
400mxrand(host)
401 register char *host;
402{
403 int hfunc;
404 static unsigned int seed;
405
406 if (seed == 0)
407 {
408 seed = (int) curtime() & 0xffff;
409 if (seed == 0)
410 seed++;
411 }
412
413 if (tTd(17, 9))
414 printf("mxrand(%s)", host);
415
416 hfunc = seed;
417 while (*host != '\0')
418 {
419 int c = *host++;
420
421 if (isascii(c) && isupper(c))
422 c = tolower(c);
423 hfunc = ((hfunc << 1) ^ c) % 2003;
424 }
425
426 hfunc &= 0xff;
427 hfunc++;
428
429 if (tTd(17, 9))
430 printf(" = %d\n", hfunc);
431 return hfunc;
432}
433/*
434** BESTMX -- find the best MX for a name
435**
436** This is really a hack, but I don't see any obvious way
437** to generalize it at the moment.
438*/
439
440/* ARGSUSED3 */
441char *
442bestmx_map_lookup(map, name, av, statp)
443 MAP *map;
444 char *name;
445 char **av;
446 int *statp;
447{
448 int nmx;
449 auto int rcode;
450 int saveopts = _res.options;
451 int i, len = 0;
452 char *p;
453 char *mxhosts[MAXMXHOSTS + 1];
454 char buf[PSBUFSIZE / 2];
455
456 _res.options &= ~(RES_DNSRCH|RES_DEFNAMES);
457 nmx = getmxrr(name, mxhosts, FALSE, &rcode);
458 _res.options = saveopts;
459 if (nmx <= 0)
460 return NULL;
461 if (bitset(MF_MATCHONLY, map->map_mflags))
462 return map_rewrite(map, name, strlen(name), NULL);
463 if ((map->map_coldelim == '\0') || (nmx == 1))
464 return map_rewrite(map, mxhosts[0], strlen(mxhosts[0]), av);
465
466 /*
467 ** We were given a -z flag (return all MXs) and there are multiple
468 ** ones. We need to build them all into a list.
469 */
470 p = buf;
471 for (i = 0; i < nmx; i++)
472 {
473 int slen;
474
475 if (strchr(mxhosts[i], map->map_coldelim) != NULL)
476 {
477 syserr("bestmx_map_lookup: MX host %.64s includes map delimiter character 0x%02X",
478 mxhosts[i], map->map_coldelim);
479 return NULL;
480 }
481 slen = strlen(mxhosts[i]);
482 if (len + slen + 2 > sizeof buf)
483 break;
484 if (i > 0)
485 {
486 *p++ = map->map_coldelim;
487 len++;
488 }
489 strcpy(p, mxhosts[i]);
490 p += slen;
491 len += slen;
492 }
493 return map_rewrite(map, buf, len, av);
494}
495/*
496** DNS_GETCANONNAME -- get the canonical name for named host using DNS
497**
498** This algorithm tries to be smart about wildcard MX records.
499** This is hard to do because DNS doesn't tell is if we matched
500** against a wildcard or a specific MX.
501**
502** We always prefer A & CNAME records, since these are presumed
503** to be specific.
504**
505** If we match an MX in one pass and lose it in the next, we use
506** the old one. For example, consider an MX matching *.FOO.BAR.COM.
507** A hostname bletch.foo.bar.com will match against this MX, but
508** will stop matching when we try bletch.bar.com -- so we know
509** that bletch.foo.bar.com must have been right. This fails if
510** there was also an MX record matching *.BAR.COM, but there are
511** some things that just can't be fixed.
512**
513** Parameters:
514** host -- a buffer containing the name of the host.
515** This is a value-result parameter.
516** hbsize -- the size of the host buffer.
517** trymx -- if set, try MX records as well as A and CNAME.
518** statp -- pointer to place to store status.
519**
520** Returns:
521** TRUE -- if the host matched.
522** FALSE -- otherwise.
523*/
524
525bool
526dns_getcanonname(host, hbsize, trymx, statp)
527 char *host;
528 int hbsize;
529 bool trymx;
530 int *statp;
531{
532 register u_char *eom, *ap;
533 register char *cp;
534 register int n;
535 HEADER *hp;
536 querybuf answer;
537 int ancount, qdcount;
538 int ret;
539 char **domain;
540 int type;
541 char **dp;
542 char *mxmatch;
543 bool amatch;
544 bool gotmx = FALSE;
545 int qtype;
546 int loopcnt;
547 char *xp;
548 char nbuf[MAX(MAXPACKET, MAXDNAME*2+2)];
549 char *searchlist[MAXDNSRCH+2];
550 extern char *gethostalias __P((char *));
551
552 if (tTd(8, 2))
553 printf("dns_getcanonname(%s, trymx=%d)\n", host, trymx);
554
555 if ((_res.options & RES_INIT) == 0 && res_init() == -1)
556 {
557 *statp = EX_UNAVAILABLE;
558 return FALSE;
559 }
560
561 /*
562 ** Initialize domain search list. If there is at least one
563 ** dot in the name, search the unmodified name first so we
564 ** find "vse.CS" in Czechoslovakia instead of in the local
565 ** domain (e.g., vse.CS.Berkeley.EDU).
566 **
567 ** Older versions of the resolver could create this
568 ** list by tearing apart the host name.
569 */
570
571 loopcnt = 0;
572cnameloop:
573 /* Check for dots in the name */
574 for (cp = host, n = 0; *cp != '\0'; cp++)
575 if (*cp == '.')
576 n++;
577
578 /*
579 ** If this is a simple name, determine whether it matches an
580 ** alias in the file defined by the environment variable HOSTALIASES.
581 */
582 if (n == 0 && (xp = gethostalias(host)) != NULL)
583 {
584 if (loopcnt++ > MAXCNAMEDEPTH)
585 {
586 syserr("loop in ${HOSTALIASES} file");
587 }
588 else
589 {
590 strncpy(host, xp, hbsize);
591 host[hbsize - 1] = '\0';
592 goto cnameloop;
593 }
594 }
595
596 /*
597 ** Build the search list.
598 ** If there is at least one dot in name, start with a null
599 ** domain to search the unmodified name first.
600 ** If name does not end with a dot and search up local domain
601 ** tree desired, append each local domain component to the
602 ** search list; if name contains no dots and default domain
603 ** name is desired, append default domain name to search list;
604 ** else if name ends in a dot, remove that dot.
605 */
606
607 dp = searchlist;
608 if (n > 0)
609 *dp++ = "";
610 if (n >= 0 && *--cp != '.' && bitset(RES_DNSRCH, _res.options))
611 {
612 for (domain = _res.dnsrch; *domain != NULL; )
613 *dp++ = *domain++;
614 }
615 else if (n == 0 && bitset(RES_DEFNAMES, _res.options))
616 {
617 *dp++ = _res.defdname;
618 }
619 else if (*cp == '.')
620 {
621 *cp = '\0';
622 }
623 *dp = NULL;
624
625 /*
626 ** Now loop through the search list, appending each domain in turn
627 ** name and searching for a match.
628 */
629
630 mxmatch = NULL;
631 qtype = T_ANY;
632
633 for (dp = searchlist; *dp != NULL; )
634 {
635 if (qtype == T_ANY)
636 gotmx = FALSE;
637 if (tTd(8, 5))
638 printf("dns_getcanonname: trying %s.%s (%s)\n",
639 host, *dp,
640 qtype == T_ANY ? "ANY" : qtype == T_A ? "A" :
641 qtype == T_MX ? "MX" : "???");
642 ret = res_querydomain(host, *dp, C_IN, qtype,
643 answer.qb2, sizeof(answer.qb2));
644 if (ret <= 0)
645 {
646 if (tTd(8, 7))
647 printf("\tNO: errno=%d, h_errno=%d\n",
648 errno, h_errno);
649
650 if (errno == ECONNREFUSED || h_errno == TRY_AGAIN)
651 {
652 /* the name server seems to be down */
653 h_errno = TRY_AGAIN;
654 *statp = EX_TEMPFAIL;
655 return FALSE;
656 }
657
658 if (h_errno != HOST_NOT_FOUND)
659 {
660 /* might have another type of interest */
661 if (qtype == T_ANY)
662 {
663 qtype = T_A;
664 continue;
665 }
666 else if (qtype == T_A && !gotmx && (trymx || **dp == '\0'))
667 {
668 qtype = T_MX;
669 continue;
670 }
671 }
672
673 /* definite no -- try the next domain */
674 dp++;
675 qtype = T_ANY;
676 continue;
677 }
678 else if (tTd(8, 7))
679 printf("\tYES\n");
680
681 /* avoid problems after truncation in tcp packets */
682 if (ret > sizeof(answer))
683 ret = sizeof(answer);
684
685 /*
686 ** Appear to have a match. Confirm it by searching for A or
687 ** CNAME records. If we don't have a local domain
688 ** wild card MX record, we will accept MX as well.
689 */
690
691 hp = (HEADER *) &answer;
692 ap = (u_char *) &answer + HFIXEDSZ;
693 eom = (u_char *) &answer + ret;
694
695 /* skip question part of response -- we know what we asked */
696 for (qdcount = ntohs(hp->qdcount); qdcount--; ap += ret + QFIXEDSZ)
697 {
698 if ((ret = dn_skipname(ap, eom)) < 0)
699 {
700 if (tTd(8, 20))
701 printf("qdcount failure (%d)\n",
702 ntohs(hp->qdcount));
703 *statp = EX_SOFTWARE;
704 return FALSE; /* ???XXX??? */
705 }
706 }
707
708 amatch = FALSE;
709 for (ancount = ntohs(hp->ancount); --ancount >= 0 && ap < eom;
710 ap += n)
711 {
712 n = dn_expand((u_char *) &answer, eom, ap,
713 (RES_UNC_T) nbuf, sizeof nbuf);
714 if (n < 0)
715 break;
716 ap += n;
717 GETSHORT(type, ap);
718 ap += INT16SZ + INT32SZ;
719 GETSHORT(n, ap);
720 switch (type)
721 {
722 case T_MX:
723 gotmx = TRUE;
724 if (**dp != '\0' && HasWildcardMX)
725 {
726 /*
727 ** If we are using MX matches and have
728 ** not yet gotten one, save this one
729 ** but keep searching for an A or
730 ** CNAME match.
731 */
732
733 if (trymx && mxmatch == NULL)
734 mxmatch = *dp;
735 continue;
736 }
737
738 /*
739 ** If we did not append a domain name, this
740 ** must have been a canonical name to start
741 ** with. Even if we did append a domain name,
742 ** in the absence of a wildcard MX this must
743 ** still be a real MX match.
744 ** Such MX matches are as good as an A match,
745 ** fall through.
746 */
747
748 case T_A:
749 /* Flag that a good match was found */
750 amatch = TRUE;
751
752 /* continue in case a CNAME also exists */
753 continue;
754
755 case T_CNAME:
756 if (DontExpandCnames)
757 {
758 /* got CNAME -- guaranteed canonical */
759 amatch = TRUE;
760 break;
761 }
762
763 if (loopcnt++ > MAXCNAMEDEPTH)
764 {
765 /*XXX should notify postmaster XXX*/
766 message("DNS failure: CNAME loop for %s",
767 host);
768 if (CurEnv->e_message == NULL)
769 {
770 char ebuf[MAXLINE];
771
772 snprintf(ebuf, sizeof ebuf,
773 "Deferred: DNS failure: CNAME loop for %.100s",
774 host);
775 CurEnv->e_message = newstr(ebuf);
776 }
777 h_errno = NO_RECOVERY;
778 *statp = EX_CONFIG;
779 return FALSE;
780 }
781
782 /* value points at name */
783 if ((ret = dn_expand((u_char *)&answer,
784 eom, ap, (RES_UNC_T) nbuf, sizeof(nbuf))) < 0)
785 break;
786 (void)strncpy(host, nbuf, hbsize); /* XXX */
787 host[hbsize - 1] = '\0';
788
789 /*
790 ** RFC 1034 section 3.6 specifies that CNAME
791 ** should point at the canonical name -- but
792 ** urges software to try again anyway.
793 */
794
795 goto cnameloop;
796
797 default:
798 /* not a record of interest */
799 continue;
800 }
801 }
802
803 if (amatch)
804 {
805 /*
806 ** Got a good match -- either an A, CNAME, or an
807 ** exact MX record. Save it and get out of here.
808 */
809
810 mxmatch = *dp;
811 break;
812 }
813
814 /*
815 ** Nothing definitive yet.
816 ** If this was a T_ANY query, we don't really know what
817 ** was returned -- it might have been a T_NS,
818 ** for example. Try T_A to be more specific
819 ** during the next pass.
820 ** If this was a T_A query and we haven't yet found a MX
821 ** match, try T_MX if allowed to do so.
822 ** Otherwise, try the next domain.
823 */
824
825 if (qtype == T_ANY)
826 qtype = T_A;
827 else if (qtype == T_A && !gotmx && (trymx || **dp == '\0'))
828 qtype = T_MX;
829 else
830 {
831 qtype = T_ANY;
832 dp++;
833 }
834 }
835
836 /* if nothing was found, we are done */
837 if (mxmatch == NULL)
838 {
839 *statp = EX_NOHOST;
840 return FALSE;
841 }
842
843 /*
844 ** Create canonical name and return.
845 ** If saved domain name is null, name was already canonical.
846 ** Otherwise append the saved domain name.
847 */
848
849 (void) snprintf(nbuf, sizeof nbuf, "%.*s%s%.*s", MAXDNAME, host,
850 *mxmatch == '\0' ? "" : ".",
851 MAXDNAME, mxmatch);
852 strncpy(host, nbuf, hbsize);
853 host[hbsize - 1] = '\0';
854 if (tTd(8, 5))
855 printf("dns_getcanonname: %s\n", host);
856 *statp = EX_OK;
857 return TRUE;
858}
859
860
861
862char *
863gethostalias(host)
864 char *host;
865{
866 char *fname;
867 FILE *fp;
868 register char *p = NULL;
869 int sff = SFF_REGONLY;
870 char buf[MAXLINE];
871 static char hbuf[MAXDNAME];
872
873 if (DontLockReadFiles)
874 sff |= SFF_NOLOCK;
875 fname = getenv("HOSTALIASES");
876 if (fname == NULL ||
877 (fp = safefopen(fname, O_RDONLY, 0, sff)) == NULL)
878 return NULL;
879 while (fgets(buf, sizeof buf, fp) != NULL)
880 {
881 for (p = buf; p != '\0' && !(isascii(*p) && isspace(*p)); p++)
882 continue;
883 if (*p == 0)
884 {
885 /* syntax error */
886 continue;
887 }
888 *p++ = '\0';
889 if (strcasecmp(buf, host) == 0)
890 break;
891 }
892
893 if (feof(fp))
894 {
895 /* no match */
896 fclose(fp);
897 return NULL;
898 }
899 fclose(fp);
900
901 /* got a match; extract the equivalent name */
902 while (*p != '\0' && isascii(*p) && isspace(*p))
903 p++;
904 host = p;
905 while (*p != '\0' && !(isascii(*p) && isspace(*p)))
906 p++;
907 *p = '\0';
908 strncpy(hbuf, host, sizeof hbuf - 1);
909 hbuf[sizeof hbuf - 1] = '\0';
910 return hbuf;
911}
912
913#endif /* NAMED_BIND */