src/src/routers/iplookup.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2018 */
   6 /* Copyright (c) The Exim Maintainers 2020 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8
   9
  10 #include "../exim.h"
  11 #include "rf_functions.h"
  12 #include "iplookup.h"
  13
  14
  15 /* IP connection types */
  16
  17 #define ip_udp 0
  18 #define ip_tcp 1
  19
  20
  21 /* Options specific to the iplookup router. */
  22
  23 optionlist iplookup_router_options[] = {
  24   { "hosts",    opt_stringptr,
  25       OPT_OFF(iplookup_router_options_block, hosts) },
  26   { "optional", opt_bool,
  27       OPT_OFF(iplookup_router_options_block, optional) },
  28   { "port",     opt_int,
  29       OPT_OFF(iplookup_router_options_block, port) },
  30   { "protocol", opt_stringptr,
  31       OPT_OFF(iplookup_router_options_block, protocol_name) },
  32   { "query",    opt_stringptr,
  33       OPT_OFF(iplookup_router_options_block, query) },
  34   { "reroute",  opt_stringptr,
  35       OPT_OFF(iplookup_router_options_block, reroute) },
  36   { "response_pattern", opt_stringptr,
  37       OPT_OFF(iplookup_router_options_block, response_pattern) },
  38   { "timeout",  opt_time,
  39       OPT_OFF(iplookup_router_options_block, timeout) }
  40 };
  41
  42 /* Size of the options list. An extern variable has to be used so that its
  43 address can appear in the tables drtables.c. */
  44
  45 int iplookup_router_options_count =
  46   sizeof(iplookup_router_options)/sizeof(optionlist);
  47
  48
  49 #ifdef MACRO_PREDEF
  50
  51 /* Dummy entries */
  52 iplookup_router_options_block iplookup_router_option_defaults = {0};
  53 void iplookup_router_init(router_instance *rblock) {}
  54 int iplookup_router_entry(router_instance *rblock, address_item *addr,
  55   struct passwd *pw, int verify, address_item **addr_local,
  56   address_item **addr_remote, address_item **addr_new,
  57   address_item **addr_succeed) {return 0;}
  58
  59 #else   /*!MACRO_PREDEF*/
  60
  61
  62 /* Default private options block for the iplookup router. */
  63
  64 iplookup_router_options_block iplookup_router_option_defaults = {
  65   -1,       /* port */
  66   ip_udp,   /* protocol */
  67   5,        /* timeout */
  68   NULL,     /* protocol_name */
  69   NULL,     /* hosts */
  70   NULL,     /* query; NULL => local_part@domain */
  71   NULL,     /* response_pattern; NULL => don't apply regex */
  72   NULL,     /* reroute; NULL => just used returned data */
  73   NULL,     /* re_response_pattern; compiled pattern */
  74   FALSE     /* optional */
  75 };
  76
  77
  78
  79 /*************************************************
  80 *          Initialization entry point            *
  81 *************************************************/
  82
  83 /* Called for each instance, after its options have been read, to enable
  84 consistency checks to be done, or anything else that needs to be set up. */
  85
  86 void
  87 iplookup_router_init(router_instance *rblock)
  88 {
  89 iplookup_router_options_block *ob =
  90   (iplookup_router_options_block *)(rblock->options_block);
  91
  92 /* A port and a host list must be given */
  93
  94 if (ob->port < 0)
  95   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
  96     "a port must be specified", rblock->name);
  97
  98 if (ob->hosts == NULL)
  99   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
 100     "a host list must be specified", rblock->name);
 101
 102 /* Translate protocol name into value */
 103
 104 if (ob->protocol_name != NULL)
 105   {
 106   if (Ustrcmp(ob->protocol_name, "udp") == 0) ob->protocol = ip_udp;
 107   else if (Ustrcmp(ob->protocol_name, "tcp") == 0) ob->protocol = ip_tcp;
 108   else log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s router:\n  "
 109     "protocol not specified as udp or tcp", rblock->name);
 110   }
 111
 112 /* If a response pattern is given, compile it now to get the error early. */
 113
 114 if (ob->response_pattern != NULL)
 115   ob->re_response_pattern =
 116     regex_must_compile(ob->response_pattern, FALSE, TRUE);
 117 }
 118
 119
 120
 121 /*************************************************
 122 *              Main entry point                  *
 123 *************************************************/
 124
 125 /* See local README for interface details. This router returns:
 126
 127 DECLINE
 128   . pattern or identification match on returned data failed
 129
 130 DEFER
 131   . failed to expand the query or rerouting string
 132   . failed to create socket ("optional" not set)
 133   . failed to find a host, failed to connect, timed out ("optional" not set)
 134   . rerouting string is not in the form localpart@domain
 135   . verifying the errors address caused a deferment or a big disaster such
 136       as an expansion failure (rf_get_errors_address)
 137   . expanding a headers_{add,remove} string caused a deferment or another
 138       expansion error (rf_get_munge_headers)
 139
 140 PASS
 141   . failed to create socket ("optional" set)
 142   . failed to find a host, failed to connect, timed out ("optional" set)
 143
 144 OK
 145   . new address added to addr_new
 146 */
 147
 148 int
 149 iplookup_router_entry(
 150   router_instance *rblock,        /* data for this instantiation */
 151   address_item *addr,             /* address we are working on */
 152   struct passwd *pw,              /* passwd entry after check_local_user */
 153   int verify,                     /* v_none/v_recipient/v_sender/v_expn */
 154   address_item **addr_local,      /* add it to this if it's local */
 155   address_item **addr_remote,     /* add it to this if it's remote */
 156   address_item **addr_new,        /* put new addresses on here */
 157   address_item **addr_succeed)    /* put old address here on success */
 158 {
 159 uschar *query = NULL;
 160 uschar *reply;
 161 uschar *hostname, *reroute, *domain;
 162 const uschar *listptr;
 163 uschar host_buffer[256];
 164 host_item *host = store_get(sizeof(host_item), FALSE);
 165 address_item *new_addr;
 166 iplookup_router_options_block *ob =
 167   (iplookup_router_options_block *)(rblock->options_block);
 168 const pcre *re = ob->re_response_pattern;
 169 int count, query_len, rc;
 170 int sep = 0;
 171
 172 DEBUG(D_route) debug_printf("%s router called for %s: domain = %s\n",
 173   rblock->name, addr->address, addr->domain);
 174
 175 reply = store_get(256, TRUE);   /* tainted data */
 176
 177 /* Build the query string to send. If not explicitly given, a default of
 178 "user@domain user@domain" is used. */
 179
 180 if (ob->query == NULL)
 181   query = string_sprintf("%s@%s %s@%s", addr->local_part, addr->domain,
 182     addr->local_part, addr->domain);
 183 else
 184   {
 185   query = expand_string(ob->query);
 186   if (query == NULL)
 187     {
 188     addr->message = string_sprintf("%s router: failed to expand %s: %s",
 189       rblock->name, ob->query, expand_string_message);
 190     return DEFER;
 191     }
 192   }
 193
 194 query_len = Ustrlen(query);
 195 DEBUG(D_route) debug_printf("%s router query is \"%s\"\n", rblock->name,
 196   string_printing(query));
 197
 198 /* Now connect to the required port for each of the hosts in turn, until a
 199 response it received. Initialization insists on the port being set and there
 200 being a host list. */
 201
 202 listptr = ob->hosts;
 203 while ((hostname = string_nextinlist(&listptr, &sep, host_buffer,
 204        sizeof(host_buffer))))
 205   {
 206   host_item *h;
 207
 208   DEBUG(D_route) debug_printf("calling host %s\n", hostname);
 209
 210   host->name = hostname;
 211   host->address = NULL;
 212   host->port = PORT_NONE;
 213   host->mx = MX_NONE;
 214   host->next = NULL;
 215
 216   if (string_is_ip_address(host->name, NULL) != 0)
 217     host->address = host->name;
 218   else
 219     {
 220 /*XXX might want dnssec request/require on an iplookup router? */
 221     int rc = host_find_byname(host, NULL, HOST_FIND_QUALIFY_SINGLE, NULL, TRUE);
 222     if (rc == HOST_FIND_FAILED || rc == HOST_FIND_AGAIN) continue;
 223     }
 224
 225   /* Loop for possible multiple IP addresses for the given name. */
 226
 227   for (h = host; h; h = h->next)
 228     {
 229     int host_af;
 230     client_conn_ctx query_cctx = {0};
 231
 232     /* Skip any hosts for which we have no address */
 233
 234     if (!h->address) continue;
 235
 236     /* Create a socket, for UDP or TCP, as configured. IPv6 addresses are
 237     detected by checking for a colon in the address. */
 238
 239     host_af = (Ustrchr(h->address, ':') != NULL)? AF_INET6 : AF_INET;
 240
 241     query_cctx.sock = ip_socket(ob->protocol == ip_udp ? SOCK_DGRAM:SOCK_STREAM,
 242       host_af);
 243     if (query_cctx.sock < 0)
 244       {
 245       if (ob->optional) return PASS;
 246       addr->message = string_sprintf("failed to create socket in %s router",
 247         rblock->name);
 248       return DEFER;
 249       }
 250
 251     /* Connect to the remote host, under a timeout. In fact, timeouts can occur
 252     here only for TCP calls; for a UDP socket, "connect" always works (the
 253     router will timeout later on the read call). */
 254 /*XXX could take advantage of TFO */
 255
 256     if (ip_connect(query_cctx.sock, host_af, h->address,ob->port, ob->timeout,
 257                 ob->protocol == ip_udp ? NULL : &tcp_fastopen_nodata) < 0)
 258       {
 259       close(query_cctx.sock);
 260       DEBUG(D_route)
 261         debug_printf("connection to %s failed: %s\n", h->address,
 262           strerror(errno));
 263       continue;
 264       }
 265
 266     /* Send the query. If it fails, just continue with the next address. */
 267
 268     if (send(query_cctx.sock, query, query_len, 0) < 0)
 269       {
 270       DEBUG(D_route) debug_printf("send to %s failed\n", h->address);
 271       (void)close(query_cctx.sock);
 272       continue;
 273       }
 274
 275     /* Read the response and close the socket. If the read fails, try the
 276     next IP address. */
 277
 278     count = ip_recv(&query_cctx, reply, sizeof(reply) - 1, time(NULL) + ob->timeout);
 279     (void)close(query_cctx.sock);
 280     if (count <= 0)
 281       {
 282       DEBUG(D_route) debug_printf("%s from %s\n", (errno == ETIMEDOUT)?
 283         "timed out" : "recv failed", h->address);
 284       *reply = 0;
 285       continue;
 286       }
 287
 288     /* Success; break the loop */
 289
 290     reply[count] = 0;
 291     DEBUG(D_route) debug_printf("%s router received \"%s\" from %s\n",
 292       rblock->name, string_printing(reply), h->address);
 293     break;
 294     }
 295
 296   /* If h == NULL we have tried all the IP addresses and failed on all of them,
 297   so we must continue to try more host names. Otherwise we have succeeded. */
 298
 299   if (h) break;
 300   }
 301
 302
 303 /* If hostname is NULL, we have failed to find any host, or failed to
 304 connect to any of the IP addresses, or timed out while reading or writing to
 305 those we have connected to. In all cases, we must pass if optional and
 306 defer otherwise. */
 307
 308 if (hostname == NULL)
 309   {
 310   DEBUG(D_route) debug_printf("%s router failed to get anything\n", rblock->name);
 311   if (ob->optional) return PASS;
 312   addr->message = string_sprintf("%s router: failed to communicate with any "
 313     "host", rblock->name);
 314   return DEFER;
 315   }
 316
 317
 318 /* If a response pattern was supplied, match the returned string against it. A
 319 failure to match causes the router to decline. After a successful match, the
 320 numerical variables for expanding the rerouted address are set up. */
 321
 322 if (re != NULL)
 323   {
 324   if (!regex_match_and_setup(re, reply, 0, -1))
 325     {
 326     DEBUG(D_route) debug_printf("%s router: %s failed to match response %s\n",
 327       rblock->name, ob->response_pattern, reply);
 328     return DECLINE;
 329     }
 330   }
 331
 332
 333 /* If no response pattern was supplied, set up $0 as the response up to the
 334 first white space (if any). Also, if no query was specified, check that what
 335 follows the white space matches user@domain. */
 336
 337 else
 338   {
 339   int n = 0;
 340   while (reply[n] != 0 && !isspace(reply[n])) n++;
 341   expand_nmax = 0;
 342   expand_nstring[0] = reply;
 343   expand_nlength[0] = n;
 344
 345   if (ob->query == NULL)
 346     {
 347     int nn = n;
 348     while (isspace(reply[nn])) nn++;
 349     if (Ustrcmp(query + query_len/2 + 1, reply+nn) != 0)
 350       {
 351       DEBUG(D_route) debug_printf("%s router: failed to match identification "
 352         "in response %s\n", rblock->name, reply);
 353       return DECLINE;
 354       }
 355     }
 356
 357   reply[n] = 0;  /* Terminate for the default case */
 358   }
 359
 360 /* If an explicit rerouting string is specified, expand it. Otherwise, use
 361 what was sent back verbatim. */
 362
 363 if (ob->reroute != NULL)
 364   {
 365   reroute = expand_string(ob->reroute);
 366   expand_nmax = -1;
 367   if (reroute == NULL)
 368     {
 369     addr->message = string_sprintf("%s router: failed to expand %s: %s",
 370       rblock->name, ob->reroute, expand_string_message);
 371     return DEFER;
 372     }
 373   }
 374 else reroute = reply;
 375
 376 /* We should now have a new address in the form user@domain. */
 377
 378 domain = Ustrchr(reroute, '@');
 379 if (domain == NULL)
 380   {
 381   log_write(0, LOG_MAIN, "%s router: reroute string %s is not of the form "
 382     "user@domain", rblock->name, reroute);
 383   addr->message = string_sprintf("%s router: reroute string %s is not of the "
 384     "form user@domain", rblock->name, reroute);
 385   return DEFER;
 386   }
 387
 388 /* Create a child address with the old one as parent. Put the new address on
 389 the chain of new addressess. */
 390
 391 new_addr = deliver_make_addr(reroute, TRUE);
 392 new_addr->parent = addr;
 393
 394 new_addr->prop = addr->prop;
 395
 396 if (addr->child_count == USHRT_MAX)
 397   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s router generated more than %d "
 398     "child addresses for <%s>", rblock->name, USHRT_MAX, addr->address);
 399 addr->child_count++;
 400 new_addr->next = *addr_new;
 401 *addr_new = new_addr;
 402
 403 /* Set up the errors address, if any, and the additional and removable headers
 404 for this new address. */
 405
 406 rc = rf_get_errors_address(addr, rblock, verify, &new_addr->prop.errors_address);
 407 if (rc != OK) return rc;
 408
 409 rc = rf_get_munge_headers(addr, rblock, &new_addr->prop.extra_headers,
 410   &new_addr->prop.remove_headers);
 411 if (rc != OK) return rc;
 412
 413 return OK;
 414 }
 415
 416 #endif   /*!MACRO_PREDEF*/
 417 /* End of routers/iplookup.c */