94cde4e046d67e9d38a5ea1734489a009bba4718
[exim.git] / src / src / routers / iplookup.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
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), GET_UNTAINTED);
165 address_item *new_addr;
166 iplookup_router_options_block *ob =
167   (iplookup_router_options_block *)(rblock->options_block);
168 const pcre2_code *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, GET_TAINTED);
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 /* not expanded so should never be tainted */
204 while ((hostname = string_nextinlist(&listptr, &sep, host_buffer,
205        sizeof(host_buffer))))
206   {
207   host_item *h;
208
209   DEBUG(D_route) debug_printf("calling host %s\n", hostname);
210
211   host->name = hostname;
212   host->address = NULL;
213   host->port = PORT_NONE;
214   host->mx = MX_NONE;
215   host->next = NULL;
216
217   if (string_is_ip_address(host->name, NULL) != 0)
218     host->address = host->name;
219   else
220     {
221 /*XXX might want dnssec request/require on an iplookup router? */
222     int rc = host_find_byname(host, NULL, HOST_FIND_QUALIFY_SINGLE, NULL, TRUE);
223     if (rc == HOST_FIND_FAILED || rc == HOST_FIND_AGAIN) continue;
224     }
225
226   /* Loop for possible multiple IP addresses for the given name. */
227
228   for (h = host; h; h = h->next)
229     {
230     int host_af;
231     client_conn_ctx query_cctx = {0};
232
233     /* Skip any hosts for which we have no address */
234
235     if (!h->address) continue;
236
237     /* Create a socket, for UDP or TCP, as configured. IPv6 addresses are
238     detected by checking for a colon in the address. */
239
240     host_af = (Ustrchr(h->address, ':') != NULL)? AF_INET6 : AF_INET;
241
242     query_cctx.sock = ip_socket(ob->protocol == ip_udp ? SOCK_DGRAM:SOCK_STREAM,
243       host_af);
244     if (query_cctx.sock < 0)
245       {
246       if (ob->optional) return PASS;
247       addr->message = string_sprintf("failed to create socket in %s router",
248         rblock->name);
249       return DEFER;
250       }
251
252     /* Connect to the remote host, under a timeout. In fact, timeouts can occur
253     here only for TCP calls; for a UDP socket, "connect" always works (the
254     router will timeout later on the read call). */
255 /*XXX could take advantage of TFO */
256
257     if (ip_connect(query_cctx.sock, host_af, h->address,ob->port, ob->timeout,
258                 ob->protocol == ip_udp ? NULL : &tcp_fastopen_nodata) < 0)
259       {
260       close(query_cctx.sock);
261       DEBUG(D_route)
262         debug_printf("connection to %s failed: %s\n", h->address,
263           strerror(errno));
264       continue;
265       }
266
267     /* Send the query. If it fails, just continue with the next address. */
268
269     if (send(query_cctx.sock, query, query_len, 0) < 0)
270       {
271       DEBUG(D_route) debug_printf("send to %s failed\n", h->address);
272       (void)close(query_cctx.sock);
273       continue;
274       }
275
276     /* Read the response and close the socket. If the read fails, try the
277     next IP address. */
278
279     count = ip_recv(&query_cctx, reply, sizeof(reply) - 1, time(NULL) + ob->timeout);
280     (void)close(query_cctx.sock);
281     if (count <= 0)
282       {
283       DEBUG(D_route) debug_printf("%s from %s\n", (errno == ETIMEDOUT)?
284         "timed out" : "recv failed", h->address);
285       *reply = 0;
286       continue;
287       }
288
289     /* Success; break the loop */
290
291     reply[count] = 0;
292     DEBUG(D_route) debug_printf("%s router received \"%s\" from %s\n",
293       rblock->name, string_printing(reply), h->address);
294     break;
295     }
296
297   /* If h == NULL we have tried all the IP addresses and failed on all of them,
298   so we must continue to try more host names. Otherwise we have succeeded. */
299
300   if (h) break;
301   }
302
303
304 /* If hostname is NULL, we have failed to find any host, or failed to
305 connect to any of the IP addresses, or timed out while reading or writing to
306 those we have connected to. In all cases, we must pass if optional and
307 defer otherwise. */
308
309 if (hostname == NULL)
310   {
311   DEBUG(D_route) debug_printf("%s router failed to get anything\n", rblock->name);
312   if (ob->optional) return PASS;
313   addr->message = string_sprintf("%s router: failed to communicate with any "
314     "host", rblock->name);
315   return DEFER;
316   }
317
318
319 /* If a response pattern was supplied, match the returned string against it. A
320 failure to match causes the router to decline. After a successful match, the
321 numerical variables for expanding the rerouted address are set up. */
322
323 if (re != NULL)
324   {
325   if (!regex_match_and_setup(re, reply, 0, -1))
326     {
327     DEBUG(D_route) debug_printf("%s router: %s failed to match response %s\n",
328       rblock->name, ob->response_pattern, reply);
329     return DECLINE;
330     }
331   }
332
333
334 /* If no response pattern was supplied, set up $0 as the response up to the
335 first white space (if any). Also, if no query was specified, check that what
336 follows the white space matches user@domain. */
337
338 else
339   {
340   int n = 0;
341   while (reply[n] != 0 && !isspace(reply[n])) n++;
342   expand_nmax = 0;
343   expand_nstring[0] = reply;
344   expand_nlength[0] = n;
345
346   if (ob->query == NULL)
347     {
348     int nn = n;
349     while (isspace(reply[nn])) nn++;
350     if (Ustrcmp(query + query_len/2 + 1, reply+nn) != 0)
351       {
352       DEBUG(D_route) debug_printf("%s router: failed to match identification "
353         "in response %s\n", rblock->name, reply);
354       return DECLINE;
355       }
356     }
357
358   reply[n] = 0;  /* Terminate for the default case */
359   }
360
361 /* If an explicit rerouting string is specified, expand it. Otherwise, use
362 what was sent back verbatim. */
363
364 if (ob->reroute != NULL)
365   {
366   reroute = expand_string(ob->reroute);
367   expand_nmax = -1;
368   if (reroute == NULL)
369     {
370     addr->message = string_sprintf("%s router: failed to expand %s: %s",
371       rblock->name, ob->reroute, expand_string_message);
372     return DEFER;
373     }
374   }
375 else reroute = reply;
376
377 /* We should now have a new address in the form user@domain. */
378
379 domain = Ustrchr(reroute, '@');
380 if (domain == NULL)
381   {
382   log_write(0, LOG_MAIN, "%s router: reroute string %s is not of the form "
383     "user@domain", rblock->name, reroute);
384   addr->message = string_sprintf("%s router: reroute string %s is not of the "
385     "form user@domain", rblock->name, reroute);
386   return DEFER;
387   }
388
389 /* Create a child address with the old one as parent. Put the new address on
390 the chain of new addressess. */
391
392 new_addr = deliver_make_addr(reroute, TRUE);
393 new_addr->parent = addr;
394
395 new_addr->prop = addr->prop;
396
397 if (addr->child_count == USHRT_MAX)
398   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s router generated more than %d "
399     "child addresses for <%s>", rblock->name, USHRT_MAX, addr->address);
400 addr->child_count++;
401 new_addr->next = *addr_new;
402 *addr_new = new_addr;
403
404 /* Set up the errors address, if any, and the additional and removable headers
405 for this new address. */
406
407 rc = rf_get_errors_address(addr, rblock, verify, &new_addr->prop.errors_address);
408 if (rc != OK) return rc;
409
410 rc = rf_get_munge_headers(addr, rblock, &new_addr->prop.extra_headers,
411   &new_addr->prop.remove_headers);
412 if (rc != OK) return rc;
413
414 return OK;
415 }
416
417 #endif   /*!MACRO_PREDEF*/
418 /* End of routers/iplookup.c */