[hcoop/debian/exim4.git] / src / routers / rf_lookup_hostlist.c

/*************************************************
*     Exim - an Internet mail transport agent    *
*************************************************/

/* Copyright (c) University of Cambridge 1995 - 2015 */
/* See the file NOTICE for conditions of use and distribution. */


#include "../exim.h"
#include "rf_functions.h"


/*************************************************
*     Look up IP addresses for a set of hosts    *
*************************************************/

/* This function is called by a router to fill in the IP addresses for a set of
hosts that are attached to an address. Each host has its name and MX value set;
and those that need processing have their address fields set NULL. Multihomed
hosts cause additional blocks to be inserted into the chain.

This function also supports pseudo-hosts whose names end with "/MX". In this
case, MX records are looked up for the name, and the list of hosts obtained
replaces the incoming "host". In other words, "x/MX" is shorthand for "those
hosts pointed to by x's MX records".

It is also possible for a port to be specified along with the host name or IP
address. The syntax is to add ":port" on to the end. This doesn't work with
IPv6 addresses, so we allow IP addresses to be enclosed in [] in order to make
this work. The specification of the port must come last, that is, after "/MX"
if that is present.

Arguments:
  rblock               the router block
  addr                 the address being routed
  ignore_target_hosts  list of hosts to ignore
  lookup_type          LK_DEFAULT or LK_BYNAME or LK_BYDNS,
		       plus LK_IPV4_{ONLY,PREFER}
  hff_code             what to do for host find failed
  addr_new             passed to rf_self_action for self=reroute

Returns:               OK
                       DEFER host lookup defer
                       PASS  timeout etc and pass_on_timeout set
                       self_action: PASS, DECLINE, DEFER, FAIL, FREEZE
                       hff_code after host find failed
*/

int
rf_lookup_hostlist(router_instance *rblock, address_item *addr,
  uschar *ignore_target_hosts, int lookup_type, int hff_code,
  address_item **addr_new)
{
BOOL self_send = FALSE;
host_item *h, *next_h, *prev;

/* Look up each host address. A lookup may add additional items into the chain
if there are multiple addresses. Hence the use of next_h to start each cycle of
the loop at the next original host. If any host is identified as being the local
host, omit it and any subsequent hosts - i.e. treat the list like an ordered
list of MX hosts. If the first host is the local host, act according to the
"self" option in the configuration. */

for (prev = NULL, h = addr->host_list; h; h = next_h)
  {
  const uschar *canonical_name;
  int rc, len, port, mx, sort_key;

  next_h = h->next;
  if (h->address) { prev = h; continue; }

  DEBUG(D_route|D_host_lookup)
    debug_printf("finding IP address for %s\n", h->name);

  /* Handle any port setting that may be on the name; it will be removed
  from the end of the name. */

  port = host_item_get_port(h);

  /* Store the previous mx and sort_key values, which were assigned in
  host_build_hostlist and will be overwritten by host_find_bydns. */

  mx = h->mx;
  sort_key = h->sort_key;

  /* If the name ends with "/MX", we interpret it to mean "the list of hosts
  pointed to by MX records with this name", and the MX record values override
  the ordering from host_build_hostlist. */

  len = Ustrlen(h->name);
  if (len > 3 && strcmpic(h->name + len - 3, US"/mx") == 0)
    {
    int whichrrs = lookup_type & LK_IPV4_ONLY
      ? HOST_FIND_BY_MX | HOST_FIND_IPV4_ONLY
      : lookup_type & LK_IPV4_PREFER
      ? HOST_FIND_BY_MX | HOST_FIND_IPV4_FIRST
      : HOST_FIND_BY_MX;

    DEBUG(D_route|D_host_lookup)
      debug_printf("doing DNS MX lookup for %s\n", h->name);

    mx = MX_NONE;
    h->name = string_copyn(h->name, len - 3);
    rc = host_find_bydns(h,
        ignore_target_hosts,
        whichrrs,			/* look only for MX records */
        NULL,				/* SRV service not relevant */
        NULL,				/* failing srv domains not relevant */
        NULL,				/* no special mx failing domains */
        &rblock->dnssec,		/* dnssec request/require */
        NULL,				/* fully_qualified_name */
        NULL);				/* indicate local host removed */
    }

  /* If explicitly configured to look up by name, or if the "host name" is
  actually an IP address, do a byname lookup. */

  else if (lookup_type & LK_BYNAME || string_is_ip_address(h->name, NULL) != 0)
    {
    DEBUG(D_route|D_host_lookup) debug_printf("calling host_find_byname\n");
    rc = host_find_byname(h, ignore_target_hosts, HOST_FIND_QUALIFY_SINGLE,
      &canonical_name, TRUE);
    }

  /* Otherwise, do a DNS lookup. If that yields "host not found", and the
  lookup type is the default (i.e. "bydns" is not explicitly configured),
  follow up with a byname lookup, just in case. */

  else
    {
    BOOL removed;
    int whichrrs = lookup_type & LK_IPV4_ONLY
      ? HOST_FIND_BY_A
      : lookup_type & LK_IPV4_PREFER
      ? HOST_FIND_BY_A | HOST_FIND_BY_AAAA | HOST_FIND_IPV4_FIRST
      : HOST_FIND_BY_A | HOST_FIND_BY_AAAA;

    DEBUG(D_route|D_host_lookup) debug_printf("doing DNS lookup\n");
    switch (rc = host_find_bydns(h, ignore_target_hosts, whichrrs, NULL,
	NULL, NULL,
	&rblock->dnssec,			/* domains for request/require */
	&canonical_name, &removed))
      {
      case HOST_FOUND:
        if (removed) setflag(addr, af_local_host_removed);
	break;
      case HOST_FIND_FAILED:
	if (lookup_type & LK_DEFAULT)
	  {
	  DEBUG(D_route|D_host_lookup)
	    debug_printf("DNS lookup failed: trying getipnodebyname\n");
	  rc = host_find_byname(h, ignore_target_hosts, HOST_FIND_QUALIFY_SINGLE,
	    &canonical_name, TRUE);
	  }
	break;
      }
    }

  /* Temporary failure defers, unless pass_on_timeout is set */

  if (rc == HOST_FIND_SECURITY)
    {
    addr->message = string_sprintf("host lookup for %s done insecurely" , h->name);
    addr->basic_errno = ERRNO_DNSDEFER;
    return DEFER;
    }
  if (rc == HOST_FIND_AGAIN)
    {
    if (rblock->pass_on_timeout)
      {
      DEBUG(D_route)
        debug_printf("%s router timed out and pass_on_timeout set\n",
          rblock->name);
      return PASS;
      }
    addr->message = string_sprintf("host lookup for %s did not complete "
      "(DNS timeout?)", h->name);
    addr->basic_errno = ERRNO_DNSDEFER;
    return DEFER;
    }

  /* Permanent failure is controlled by host_find_failed */

  if (rc == HOST_FIND_FAILED)
    {
    if (hff_code == hff_ignore)
      {
      if (prev == NULL) addr->host_list = next_h; else prev->next = next_h;
      continue;   /* With the next host, leave prev unchanged */
      }

    if (hff_code == hff_pass) return PASS;
    if (hff_code == hff_decline) return DECLINE;

    addr->basic_errno = ERRNO_UNKNOWNHOST;
    addr->message =
      string_sprintf("lookup of host \"%s\" failed in %s router%s",
        h->name, rblock->name,
        f.host_find_failed_syntax? ": syntax error in name" : "");

    if (hff_code == hff_defer) return DEFER;
    if (hff_code == hff_fail) return FAIL;

    addr->special_action = SPECIAL_FREEZE;
    return DEFER;
    }

  /* Deal with the settings that were previously cleared:
  port, mx and sort_key. */

  if (port != PORT_NONE)
    {
    host_item *hh;
    for (hh = h; hh != next_h; hh = hh->next) hh->port = port;
    }

  if (mx != MX_NONE)
    {
    host_item *hh;
    for (hh = h; hh != next_h; hh = hh->next)
      {
      hh->mx = mx;
      hh->sort_key = sort_key;
      }
    }

  /* A local host gets chopped, with its successors, if there are previous
  hosts. Otherwise the self option is used. If it is set to "send", any
  subsequent hosts that are also the local host do NOT get chopped. */

  if (rc == HOST_FOUND_LOCAL && !self_send)
    {
    if (prev)
      {
      DEBUG(D_route)
        {
        debug_printf("Removed from host list:\n");
        for (; h != NULL; h = h->next) debug_printf("  %s\n", h->name);
        }
      prev->next = NULL;
      setflag(addr, af_local_host_removed);
      break;
      }
    rc = rf_self_action(addr, h, rblock->self_code, rblock->self_rewrite,
      rblock->self, addr_new);
    if (rc != OK)
      {
      addr->host_list = NULL;   /* Kill the host list for */
      return rc;                /* anything other than "send" */
      }
    self_send = TRUE;
    }

  /* Ensure that prev is the host before next_h; this will not be h if a lookup
  found multiple addresses or multiple MX records. */

  prev = h;
  while (prev->next != next_h) prev = prev->next;
  }

return OK;
}

/* End of rf_lookup_hostlist.c */
Commit	Line	Data
420a0d19 CE	1	/*************************************************
	2	* Exim - an Internet mail transport agent *
	3	*************************************************/
	4
2ea97746	5	/* Copyright (c) University of Cambridge 1995 - 2015 */
420a0d19 CE	6	/* See the file NOTICE for conditions of use and distribution. */
	7
	8
	9	#include "../exim.h"
	10	#include "rf_functions.h"
	11
	12
	13
	14	/*************************************************
	15	* Look up IP addresses for a set of hosts *
	16	*************************************************/
	17
	18	/* This function is called by a router to fill in the IP addresses for a set of
	19	hosts that are attached to an address. Each host has its name and MX value set;
	20	and those that need processing have their address fields set NULL. Multihomed
	21	hosts cause additional blocks to be inserted into the chain.
	22
	23	This function also supports pseudo-hosts whose names end with "/MX". In this
	24	case, MX records are looked up for the name, and the list of hosts obtained
	25	replaces the incoming "host". In other words, "x/MX" is shorthand for "those
	26	hosts pointed to by x's MX records".
	27
	28	It is also possible for a port to be specified along with the host name or IP
	29	address. The syntax is to add ":port" on to the end. This doesn't work with
	30	IPv6 addresses, so we allow IP addresses to be enclosed in [] in order to make
	31	this work. The specification of the port must come last, that is, after "/MX"
	32	if that is present.
	33
	34	Arguments:
	35	rblock the router block
	36	addr the address being routed
	37	ignore_target_hosts list of hosts to ignore
2ea97746 CE	38	lookup_type LK_DEFAULT or LK_BYNAME or LK_BYDNS,
2ea97746 CE	39	plus LK_IPV4_{ONLY,PREFER}
420a0d19 CE	40	hff_code what to do for host find failed
	41	addr_new passed to rf_self_action for self=reroute
	42
	43	Returns: OK
	44	DEFER host lookup defer
	45	PASS timeout etc and pass_on_timeout set
	46	self_action: PASS, DECLINE, DEFER, FAIL, FREEZE
	47	hff_code after host find failed
	48	*/
	49
	50	int
	51	rf_lookup_hostlist(router_instance rblock, address_item addr,
	52	uschar *ignore_target_hosts, int lookup_type, int hff_code,
	53	address_item **addr_new)
	54	{
	55	BOOL self_send = FALSE;
	56	host_item h, next_h, *prev;
	57
	58	/* Look up each host address. A lookup may add additional items into the chain
	59	if there are multiple addresses. Hence the use of next_h to start each cycle of
	60	the loop at the next original host. If any host is identified as being the local
	61	host, omit it and any subsequent hosts - i.e. treat the list like an ordered
	62	list of MX hosts. If the first host is the local host, act according to the
	63	"self" option in the configuration. */
	64
2ea97746	65	for (prev = NULL, h = addr->host_list; h; h = next_h)
420a0d19	66	{
2ea97746 CE	67	const uschar *canonical_name;
2ea97746 CE	68	int rc, len, port, mx, sort_key;
420a0d19 CE	69
420a0d19 CE	70	next_h = h->next;
2ea97746	71	if (h->address) { prev = h; continue; }
420a0d19 CE	72
	73	DEBUG(D_route\|D_host_lookup)
	74	debug_printf("finding IP address for %s\n", h->name);
	75
	76	/* Handle any port setting that may be on the name; it will be removed
	77	from the end of the name. */
	78
	79	port = host_item_get_port(h);
	80
2ea97746 CE	81	/* Store the previous mx and sort_key values, which were assigned in
	82	host_build_hostlist and will be overwritten by host_find_bydns. */
	83
	84	mx = h->mx;
	85	sort_key = h->sort_key;
	86
420a0d19	87	/* If the name ends with "/MX", we interpret it to mean "the list of hosts
2ea97746 CE	88	pointed to by MX records with this name", and the MX record values override
2ea97746 CE	89	the ordering from host_build_hostlist. */
420a0d19 CE	90
	91	len = Ustrlen(h->name);
	92	if (len > 3 && strcmpic(h->name + len - 3, US"/mx") == 0)
	93	{
2ea97746 CE	94	int whichrrs = lookup_type & LK_IPV4_ONLY
	95	? HOST_FIND_BY_MX \| HOST_FIND_IPV4_ONLY
	96	: lookup_type & LK_IPV4_PREFER
	97	? HOST_FIND_BY_MX \| HOST_FIND_IPV4_FIRST
	98	: HOST_FIND_BY_MX;
	99
420a0d19 CE	100	DEBUG(D_route\|D_host_lookup)
	101	debug_printf("doing DNS MX lookup for %s\n", h->name);
	102
2ea97746	103	mx = MX_NONE;
420a0d19 CE	104	h->name = string_copyn(h->name, len - 3);
	105	rc = host_find_bydns(h,
	106	ignore_target_hosts,
2ea97746 CE	107	whichrrs, /* look only for MX records */
	108	NULL, /* SRV service not relevant */
	109	NULL, /* failing srv domains not relevant */
	110	NULL, /* no special mx failing domains */
	111	&rblock->dnssec, /* dnssec request/require */
	112	NULL, /* fully_qualified_name */
	113	NULL); /* indicate local host removed */
420a0d19 CE	114	}
	115
	116	/* If explicitly configured to look up by name, or if the "host name" is
	117	actually an IP address, do a byname lookup. */
	118
2ea97746	119	else if (lookup_type & LK_BYNAME \|\| string_is_ip_address(h->name, NULL) != 0)
420a0d19 CE	120	{
	121	DEBUG(D_route\|D_host_lookup) debug_printf("calling host_find_byname\n");
	122	rc = host_find_byname(h, ignore_target_hosts, HOST_FIND_QUALIFY_SINGLE,
	123	&canonical_name, TRUE);
	124	}
	125
	126	/* Otherwise, do a DNS lookup. If that yields "host not found", and the
	127	lookup type is the default (i.e. "bydns" is not explicitly configured),
	128	follow up with a byname lookup, just in case. */
	129
	130	else
	131	{
	132	BOOL removed;
2ea97746 CE	133	int whichrrs = lookup_type & LK_IPV4_ONLY
	134	? HOST_FIND_BY_A
	135	: lookup_type & LK_IPV4_PREFER
	136	? HOST_FIND_BY_A \| HOST_FIND_BY_AAAA \| HOST_FIND_IPV4_FIRST
	137	: HOST_FIND_BY_A \| HOST_FIND_BY_AAAA;
	138
420a0d19	139	DEBUG(D_route\|D_host_lookup) debug_printf("doing DNS lookup\n");
2ea97746 CE	140	switch (rc = host_find_bydns(h, ignore_target_hosts, whichrrs, NULL,
	141	NULL, NULL,
	142	&rblock->dnssec, /* domains for request/require */
	143	&canonical_name, &removed))
420a0d19	144	{
2ea97746 CE	145	case HOST_FOUND:
	146	if (removed) setflag(addr, af_local_host_removed);
	147	break;
	148	case HOST_FIND_FAILED:
	149	if (lookup_type & LK_DEFAULT)
	150	{
	151	DEBUG(D_route\|D_host_lookup)
	152	debug_printf("DNS lookup failed: trying getipnodebyname\n");
	153	rc = host_find_byname(h, ignore_target_hosts, HOST_FIND_QUALIFY_SINGLE,
	154	&canonical_name, TRUE);
	155	}
	156	break;
420a0d19 CE	157	}
	158	}
	159
	160	/* Temporary failure defers, unless pass_on_timeout is set */
	161
2ea97746 CE	162	if (rc == HOST_FIND_SECURITY)
	163	{
	164	addr->message = string_sprintf("host lookup for %s done insecurely" , h->name);
	165	addr->basic_errno = ERRNO_DNSDEFER;
	166	return DEFER;
	167	}
420a0d19 CE	168	if (rc == HOST_FIND_AGAIN)
	169	{
	170	if (rblock->pass_on_timeout)
	171	{
	172	DEBUG(D_route)
	173	debug_printf("%s router timed out and pass_on_timeout set\n",
	174	rblock->name);
	175	return PASS;
	176	}
	177	addr->message = string_sprintf("host lookup for %s did not complete "
	178	"(DNS timeout?)", h->name);
	179	addr->basic_errno = ERRNO_DNSDEFER;
	180	return DEFER;
	181	}
	182
	183	/* Permanent failure is controlled by host_find_failed */
	184
	185	if (rc == HOST_FIND_FAILED)
	186	{
	187	if (hff_code == hff_ignore)
	188	{
	189	if (prev == NULL) addr->host_list = next_h; else prev->next = next_h;
	190	continue; /* With the next host, leave prev unchanged */
	191	}
	192
	193	if (hff_code == hff_pass) return PASS;
	194	if (hff_code == hff_decline) return DECLINE;
	195
2ea97746	196	addr->basic_errno = ERRNO_UNKNOWNHOST;
420a0d19 CE	197	addr->message =
	198	string_sprintf("lookup of host \"%s\" failed in %s router%s",
	199	h->name, rblock->name,
2ea97746	200	f.host_find_failed_syntax? ": syntax error in name" : "");
420a0d19 CE	201
	202	if (hff_code == hff_defer) return DEFER;
	203	if (hff_code == hff_fail) return FAIL;
	204
	205	addr->special_action = SPECIAL_FREEZE;
	206	return DEFER;
	207	}
	208
2ea97746 CE	209	/* Deal with the settings that were previously cleared:
2ea97746 CE	210	port, mx and sort_key. */
420a0d19 CE	211
	212	if (port != PORT_NONE)
	213	{
	214	host_item *hh;
	215	for (hh = h; hh != next_h; hh = hh->next) hh->port = port;
	216	}
	217
2ea97746 CE	218	if (mx != MX_NONE)
	219	{
	220	host_item *hh;
	221	for (hh = h; hh != next_h; hh = hh->next)
	222	{
	223	hh->mx = mx;
	224	hh->sort_key = sort_key;
	225	}
	226	}
	227
420a0d19 CE	228	/* A local host gets chopped, with its successors, if there are previous
	229	hosts. Otherwise the self option is used. If it is set to "send", any
	230	subsequent hosts that are also the local host do NOT get chopped. */
	231
	232	if (rc == HOST_FOUND_LOCAL && !self_send)
	233	{
2ea97746	234	if (prev)
420a0d19 CE	235	{
	236	DEBUG(D_route)
	237	{
	238	debug_printf("Removed from host list:\n");
	239	for (; h != NULL; h = h->next) debug_printf(" %s\n", h->name);
	240	}
	241	prev->next = NULL;
	242	setflag(addr, af_local_host_removed);
	243	break;
	244	}
	245	rc = rf_self_action(addr, h, rblock->self_code, rblock->self_rewrite,
	246	rblock->self, addr_new);
	247	if (rc != OK)
	248	{
	249	addr->host_list = NULL; /* Kill the host list for */
	250	return rc; /* anything other than "send" */
	251	}
	252	self_send = TRUE;
	253	}
	254
	255	/* Ensure that prev is the host before next_h; this will not be h if a lookup
	256	found multiple addresses or multiple MX records. */
	257
	258	prev = h;
	259	while (prev->next != next_h) prev = prev->next;
	260	}
	261
	262	return OK;
	263	}
	264
	265	/* End of rf_lookup_hostlist.c */