readsocket expansion: response caching
[exim.git] / src / src / lookups / readsock.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) Jeremy Harris 2020 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 #include "../exim.h"
9 #include "lf_functions.h"
10
11
12 static int
13 internal_readsock_open(client_conn_ctx * cctx, const uschar * sspec,
14 int timeout, BOOL do_tls, uschar ** errmsg)
15 {
16 int sep = ',';
17 uschar * ele;
18 const uschar * server_name;
19 host_item host;
20
21 if (Ustrncmp(sspec, "inet:", 5) == 0)
22 {
23 int port;
24 uschar * port_name;
25
26 DEBUG(D_lookup)
27 debug_printf_indent(" new inet socket needed for readsocket\n");
28
29 server_name = sspec + 5;
30 port_name = Ustrrchr(server_name, ':');
31
32 /* Sort out the port */
33
34 if (!port_name)
35 {
36 /* expand_string_message results in an EXPAND_FAIL, from our
37 only caller. Lack of it gets a SOCK_FAIL; we feed back via errmsg
38 for that, which gets copied to search_error_message. */
39
40 expand_string_message =
41 string_sprintf("missing port for readsocket %s", sspec);
42 return FAIL;
43 }
44 *port_name++ = 0; /* Terminate server name */
45
46 if (isdigit(*port_name))
47 {
48 uschar *end;
49 port = Ustrtol(port_name, &end, 0);
50 if (end != port_name + Ustrlen(port_name))
51 {
52 expand_string_message =
53 string_sprintf("invalid port number %s", port_name);
54 return FAIL;
55 }
56 }
57 else
58 {
59 struct servent *service_info = getservbyname(CS port_name, "tcp");
60 if (!service_info)
61 {
62 expand_string_message = string_sprintf("unknown port \"%s\"",
63 port_name);
64 return FAIL;
65 }
66 port = ntohs(service_info->s_port);
67 }
68
69 /* Not having the request-string here in the open routine means
70 that we cannot do TFO; a pity */
71
72 cctx->sock = ip_connectedsocket(SOCK_STREAM, server_name, port, port,
73 timeout, &host, errmsg, NULL);
74 callout_address = NULL;
75 if (cctx->sock < 0)
76 return FAIL;
77 }
78
79 else
80 {
81 struct sockaddr_un sockun; /* don't call this "sun" ! */
82 int rc;
83
84 DEBUG(D_lookup)
85 debug_printf_indent(" new unix socket needed for readsocket\n");
86
87 if ((cctx->sock = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
88 {
89 *errmsg = string_sprintf("failed to create socket: %s", strerror(errno));
90 return FAIL;
91 }
92
93 sockun.sun_family = AF_UNIX;
94 sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1),
95 sspec);
96 server_name = US sockun.sun_path;
97
98 sigalrm_seen = FALSE;
99 ALARM(timeout);
100 rc = connect(cctx->sock, (struct sockaddr *)(&sockun), sizeof(sockun));
101 ALARM_CLR(0);
102 if (sigalrm_seen)
103 {
104 *errmsg = US "socket connect timed out";
105 goto bad;
106 }
107 if (rc < 0)
108 {
109 *errmsg = string_sprintf("failed to connect to socket "
110 "%s: %s", sspec, strerror(errno));
111 goto bad;
112 }
113 host.name = server_name;
114 host.address = US"";
115 }
116
117 #ifndef DISABLE_TLS
118 if (do_tls)
119 {
120 smtp_connect_args conn_args = {.host = &host };
121 tls_support tls_dummy = {.sni=NULL};
122 uschar * errstr;
123
124 if (!tls_client_start(cctx, &conn_args, NULL, &tls_dummy, &errstr))
125 {
126 *errmsg = string_sprintf("TLS connect failed: %s", errstr);
127 goto bad;
128 }
129 }
130 #endif
131
132 DEBUG(D_expand|D_lookup) debug_printf_indent(" connected to socket %s\n", sspec);
133 return OK;
134
135 bad:
136 close(cctx->sock);
137 return FAIL;
138 }
139
140 /* All use of allocations will be done against the POOL_SEARCH memory,
141 which is freed once by search_tidyup(). */
142
143 /*************************************************
144 * Open entry point *
145 *************************************************/
146
147 /* See local README for interface description */
148 /* We just create a placeholder record with a closed socket, so
149 that connection cacheing at the framework layer works. */
150
151 static void *
152 readsock_open(const uschar * filename, uschar ** errmsg)
153 {
154 client_conn_ctx * cctx = store_get(sizeof(*cctx), FALSE);
155 cctx->sock = -1;
156 cctx->tls_ctx = NULL;
157 DEBUG(D_lookup) debug_printf_indent("readsock: allocated context\n");
158 return cctx;
159 }
160
161
162
163
164
165 /*************************************************
166 * Find entry point for lsearch *
167 *************************************************/
168
169 /* See local README for interface description */
170
171 static int
172 readsock_find(void * handle, const uschar * filename, const uschar * keystring,
173 int length, uschar ** result, uschar ** errmsg, uint * do_cache,
174 const uschar * opts)
175 {
176 client_conn_ctx * cctx = handle;
177 int sep = ',';
178 struct {
179 BOOL do_shutdown:1;
180 BOOL do_tls:1;
181 BOOL cache:1;
182 } lf = {.do_shutdown = TRUE};
183 uschar * eol = NULL;
184 int timeout = 5;
185 FILE * fp;
186 gstring * yield;
187 int ret = DEFER;
188
189 DEBUG(D_lookup) debug_printf_indent("readsock: file=\"%s\" key=\"%s\" len=%d opts=\"%s\"\n", filename, keystring, length, opts);
190
191 /* Parse options */
192
193 if (opts) for (uschar * s; s = string_nextinlist(&opts, &sep, NULL, 0); )
194 if (Ustrncmp(s, "timeout=", 8) == 0)
195 timeout = readconf_readtime(s + 8, 0, FALSE);
196 else if (Ustrncmp(s, "shutdown=", 9) == 0)
197 lf.do_shutdown = Ustrcmp(s + 9, "no") != 0;
198 #ifndef DISABLE_TLS
199 else if (Ustrncmp(s, "tls=", 4) == 0 && Ustrcmp(s + 4, US"no") != 0)
200 lf.do_tls = TRUE;
201 #endif
202 else if (Ustrncmp(s, "eol=", 4) == 0)
203 eol = s + 4;
204 else if (Ustrcmp(s, "cache=yes") == 0)
205 lf.cache = TRUE;
206 else if (Ustrcmp(s, "send=no") == 0)
207 length = 0;
208
209 if (!filename) return FAIL; /* Server spec is required */
210
211 /* Open the socket, if not cached */
212
213 if (cctx->sock == -1)
214 if (internal_readsock_open(cctx, filename, timeout, lf.do_tls, errmsg) != OK)
215 return ret;
216
217 testharness_pause_ms(100); /* Allow sequencing of test actions */
218
219 /* Write the request string, if not empty or already done */
220
221 if (length)
222 {
223 if ((
224 #ifndef DISABLE_TLS
225 cctx->tls_ctx ? tls_write(cctx->tls_ctx, keystring, length, FALSE) :
226 #endif
227 write(cctx->sock, keystring, length)) != length)
228 {
229 *errmsg = string_sprintf("request write to socket "
230 "failed: %s", strerror(errno));
231 goto out;
232 }
233 }
234
235 /* Shut down the sending side of the socket. This helps some servers to
236 recognise that it is their turn to do some work. Just in case some
237 system doesn't have this function, make it conditional. */
238
239 #ifdef SHUT_WR
240 if (!cctx->tls_ctx && lf.do_shutdown)
241 shutdown(cctx->sock, SHUT_WR);
242 #endif
243
244 testharness_pause_ms(100);
245
246 /* Now we need to read from the socket, under a timeout. The function
247 that reads a file can be used. If we're using a stdio buffered read,
248 and might need later write ops on the socket, the stdio must be in
249 writable mode or the underlying socket goes non-writable. */
250
251 if (!cctx->tls_ctx)
252 fp = fdopen(cctx->sock, lf.do_shutdown ? "rb" : "wb");
253
254 sigalrm_seen = FALSE;
255 ALARM(timeout);
256 yield =
257 #ifndef DISABLE_TLS
258 cctx->tls_ctx ? cat_file_tls(cctx->tls_ctx, NULL, eol) :
259 #endif
260 cat_file(fp, NULL, eol);
261 ALARM_CLR(0);
262
263 if (sigalrm_seen)
264 { *errmsg = US "socket read timed out"; goto out; }
265
266 *result = yield ? string_from_gstring(yield) : US"";
267 ret = OK;
268 if (!lf.cache) *do_cache = 0;
269
270 out:
271
272 (void) close(cctx->sock);
273 cctx->sock = -1;
274 return ret;
275 }
276
277
278
279 /*************************************************
280 * Close entry point *
281 *************************************************/
282
283 /* See local README for interface description */
284
285 static void
286 readsock_close(void * handle)
287 {
288 client_conn_ctx * cctx = handle;
289 if (cctx->sock < 0) return;
290 #ifndef DISABLE_TLS
291 if (cctx->tls_ctx) tls_close(cctx->tls_ctx, TRUE);
292 #endif
293 close(cctx->sock);
294 cctx->sock = -1;
295 }
296
297
298
299 static lookup_info readsock_lookup_info = {
300 .name = US"readsock", /* lookup name */
301 .type = lookup_querystyle,
302 .open = readsock_open, /* open function */
303 .check = NULL,
304 .find = readsock_find, /* find function */
305 .close = readsock_close,
306 .tidy = NULL,
307 .quote = NULL, /* no quoting function */
308 .version_report = NULL
309 };
310
311
312 #ifdef DYNLOOKUP
313 #define readsock_lookup_module_info _lookup_module_info
314 #endif
315
316 static lookup_info *_lookup_list[] = { &readsock_lookup_info };
317 lookup_module_info readsock_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 1 };
318
319 /* End of lookups/readsock.c */