src/src/lookups/readsock.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2021 - 2022 */
   6 /* Copyright (c) Jeremy Harris 2020 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8 /* SPDX-License-Identifier: GPL-2.0-or-later */
   9
  10 #include "../exim.h"
  11 #include "lf_functions.h"
  12
  13
  14 static int
  15 internal_readsock_open(client_conn_ctx * cctx, const uschar * sspec,
  16   int timeout, uschar * do_tls, uschar ** errmsg)
  17 {
  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   if (!tls_client_adjunct_start(&host, cctx, do_tls, errmsg))
 120     goto bad;
 121 #endif
 122
 123 DEBUG(D_expand|D_lookup) debug_printf_indent("  connected to socket %s\n", sspec);
 124 return OK;
 125
 126 bad:
 127   close(cctx->sock);
 128   return FAIL;
 129 }
 130
 131 /* All use of allocations will be done against the POOL_SEARCH memory,
 132 which is freed once by search_tidyup(). */
 133
 134 /*************************************************
 135 *              Open entry point                  *
 136 *************************************************/
 137
 138 /* See local README for interface description */
 139 /* We just create a placeholder record with a closed socket, so
 140 that connection cacheing at the framework layer works. */
 141
 142 static void *
 143 readsock_open(const uschar * filename, uschar ** errmsg)
 144 {
 145 client_conn_ctx * cctx = store_get(sizeof(*cctx), GET_UNTAINTED);
 146 cctx->sock = -1;
 147 cctx->tls_ctx = NULL;
 148 DEBUG(D_lookup) debug_printf_indent("readsock: allocated context\n");
 149 return cctx;
 150 }
 151
 152
 153
 154
 155
 156 /*************************************************
 157 *         Find entry point for lsearch           *
 158 *************************************************/
 159
 160 /* See local README for interface description */
 161
 162 static int
 163 readsock_find(void * handle, const uschar * filename, const uschar * keystring,
 164   int length, uschar ** result, uschar ** errmsg, uint * do_cache,
 165   const uschar * opts)
 166 {
 167 client_conn_ctx * cctx = handle;
 168 int sep = ',';
 169 struct {
 170         BOOL do_shutdown:1;
 171         BOOL cache:1;
 172         uschar * do_tls;        /* NULL, empty-string, or SNI */
 173 } lf = {.do_shutdown = TRUE};
 174 uschar * eol = NULL;
 175 int timeout = 5;
 176 gstring * yield;
 177 int ret = DEFER;
 178
 179 DEBUG(D_lookup)
 180   debug_printf_indent("readsock: file=\"%s\" key=\"%s\" len=%d opts=\"%s\"\n",
 181     filename, keystring, length, opts);
 182
 183 /* Parse options */
 184
 185 if (opts) for (uschar * s; s = string_nextinlist(&opts, &sep, NULL, 0); )
 186   if (Ustrncmp(s, "timeout=", 8) == 0)
 187     timeout = readconf_readtime(s + 8, 0, FALSE);
 188   else if (Ustrncmp(s, "shutdown=", 9) == 0)
 189     lf.do_shutdown = Ustrcmp(s + 9, "no") != 0;
 190 #ifndef DISABLE_TLS
 191   else if (Ustrncmp(s, "tls=", 4) == 0 && Ustrcmp(s + 4, US"no") != 0 && !lf.do_tls)
 192     lf.do_tls = US"";
 193   else if (Ustrncmp(s, "sni=", 4) == 0)
 194     lf.do_tls = s + 4;
 195 #endif
 196   else if (Ustrncmp(s, "eol=", 4) == 0)
 197     eol = string_unprinting(s + 4);
 198   else if (Ustrcmp(s, "cache=yes") == 0)
 199     lf.cache = TRUE;
 200   else if (Ustrcmp(s, "send=no") == 0)
 201     length = 0;
 202
 203 if (!filename) return FAIL;     /* Server spec is required */
 204
 205 /* Open the socket, if not cached */
 206
 207 if (cctx->sock == -1)
 208   if (internal_readsock_open(cctx, filename, timeout, lf.do_tls, errmsg) != OK)
 209     return ret;
 210
 211 testharness_pause_ms(100);      /* Allow sequencing of test actions */
 212
 213 /* Write the request string, if not empty or already done */
 214
 215 if (length)
 216   {
 217   if ((
 218 #ifndef DISABLE_TLS
 219       cctx->tls_ctx ? tls_write(cctx->tls_ctx, keystring, length, FALSE) :
 220 #endif
 221                       write(cctx->sock, keystring, length)) != length)
 222     {
 223     *errmsg = string_sprintf("request write to socket "
 224       "failed: %s", strerror(errno));
 225     goto out;
 226     }
 227   }
 228
 229 /* Shut down the sending side of the socket. This helps some servers to
 230 recognise that it is their turn to do some work. Just in case some
 231 system doesn't have this function, make it conditional. */
 232
 233 #ifdef SHUT_WR
 234 if (!cctx->tls_ctx && lf.do_shutdown)
 235   shutdown(cctx->sock, SHUT_WR);
 236 #endif
 237
 238 testharness_pause_ms(100);
 239
 240 /* Now we need to read from the socket, under a timeout. The function
 241 that reads a file can be used.  If we're using a stdio buffered read,
 242 and might need later write ops on the socket, the stdio must be in
 243 writable mode or the underlying socket goes non-writable. */
 244
 245 sigalrm_seen = FALSE;
 246 #ifdef DISABLE_TLS
 247 if (TRUE)
 248 #else
 249 if (!cctx->tls_ctx)
 250 #endif
 251   {
 252   FILE * fp = fdopen(cctx->sock, "rb");
 253   if (!fp)
 254     {
 255     log_write(0, LOG_MAIN|LOG_PANIC, "readsock fdopen: %s\n", strerror(errno));
 256     goto out;
 257     }
 258   ALARM(timeout);
 259   yield = cat_file(fp, NULL, eol);
 260   }
 261 else
 262   {
 263   ALARM(timeout);
 264   yield = cat_file_tls(cctx->tls_ctx, NULL, eol);
 265   }
 266
 267 ALARM_CLR(0);
 268
 269 if (sigalrm_seen)
 270   { *errmsg = US "socket read timed out"; goto out; }
 271
 272 *result = yield ? string_from_gstring(yield) : US"";
 273 ret = OK;
 274 if (!lf.cache) *do_cache = 0;
 275
 276 out:
 277
 278 (void) close(cctx->sock);
 279 cctx->sock = -1;
 280 return ret;
 281 }
 282
 283
 284
 285 /*************************************************
 286 *              Close entry point                 *
 287 *************************************************/
 288
 289 /* See local README for interface description */
 290
 291 static void
 292 readsock_close(void * handle)
 293 {
 294 client_conn_ctx * cctx = handle;
 295 if (cctx->sock < 0) return;
 296 #ifndef DISABLE_TLS
 297 if (cctx->tls_ctx) tls_close(cctx->tls_ctx, TRUE);
 298 #endif
 299 close(cctx->sock);
 300 cctx->sock = -1;
 301 }
 302
 303
 304
 305 static lookup_info readsock_lookup_info = {
 306   .name = US"readsock",                 /* lookup name */
 307   .type = lookup_querystyle,
 308   .open = readsock_open,                /* open function */
 309   .check = NULL,
 310   .find = readsock_find,                /* find function */
 311   .close = readsock_close,
 312   .tidy = NULL,
 313   .quote = NULL,                        /* no quoting function */
 314   .version_report = NULL
 315 };
 316
 317
 318 #ifdef DYNLOOKUP
 319 #define readsock_lookup_module_info _lookup_module_info
 320 #endif
 321
 322 static lookup_info *_lookup_list[] = { &readsock_lookup_info };
 323 lookup_module_info readsock_lookup_module_info = { LOOKUP_MODULE_INFO_MAGIC, _lookup_list, 1 };
 324
 325 /* End of lookups/readsock.c */