src/src/spool_out.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 /* Functions for writing spool files, and moving them about. */
  10
  11
  12 #include "exim.h"
  13
  14
  15
  16 /*************************************************
  17 *       Deal with header writing errors          *
  18 *************************************************/
  19
  20 /* This function is called immediately after errors in writing the spool, with
  21 errno still set. It creates an error message, depending on the circumstances.
  22 If errmsg is NULL, it logs the message and panic-dies. Otherwise errmsg is set
  23 to point to the message, and -1 is returned. This function makes the code of
  24 spool_write_header() a bit neater.
  25
  26 Arguments:
  27    where      SW_RECEIVING, SW_DELIVERING, or SW_MODIFYING
  28    errmsg     where to put the message; NULL => panic-die
  29    s          text to add to log string
  30    temp_name  name of temp file to unlink
  31    f          FILE to close, if not NULL
  32
  33 Returns:      -1 if errmsg is not NULL; otherwise doesn't return
  34 */
  35
  36 static int
  37 spool_write_error(int where, uschar **errmsg, uschar *s, uschar *temp_name,
  38   FILE *f)
  39 {
  40 uschar *msg = where == SW_RECEIVING
  41   ? string_sprintf("spool file %s error while receiving from %s: %s", s,
  42       sender_fullhost ? sender_fullhost : sender_ident,
  43       strerror(errno))
  44   : string_sprintf("spool file %s error while %s: %s", s,
  45       where == SW_DELIVERING ? "delivering" : "modifying",
  46       strerror(errno));
  47
  48 if (temp_name) Uunlink(temp_name);
  49 if (f) (void)fclose(f);
  50
  51 if (errmsg)
  52   *errmsg = msg;
  53 else
  54   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s", msg);
  55
  56 return -1;
  57 }
  58
  59
  60
  61 /*************************************************
  62 *            Open file under temporary name      *
  63 *************************************************/
  64
  65 /* This is used for opening spool files under a temporary name,
  66 with a single attempt at deleting if they already exist.
  67
  68 Argument: temporary name for spool header file
  69 Returns:  file descriptor of open file, or < 0 on failure, with errno unchanged
  70 */
  71
  72 int
  73 spool_open_temp(uschar *temp_name)
  74 {
  75 int fd = Uopen(temp_name, O_RDWR|O_CREAT|O_EXCL, SPOOL_MODE);
  76
  77 /* If the file already exists, something has gone wrong. This process may well
  78 have previously created the file if it is delivering more than one address, but
  79 it should have renamed it almost immediately. A file could, however, be left
  80 around as a result of a system crash, and by coincidence this process might
  81 have the same pid. We therefore have one go at unlinking it before giving up.
  82 */
  83
  84 if (fd < 0 && errno == EEXIST)
  85   {
  86   DEBUG(D_any) debug_printf("%s exists: unlinking\n", temp_name);
  87   Uunlink(temp_name);
  88   fd = Uopen(temp_name, O_RDWR|O_CREAT|O_EXCL, SPOOL_MODE);
  89   }
  90
  91 /* If the file has been opened, make sure the file's group is the Exim gid, and
  92 double-check the mode because the group setting doesn't always get set
  93 automatically. */
  94
  95 if (fd >= 0)
  96   if (exim_fchown(fd, exim_uid, exim_gid, temp_name) || fchmod(fd, SPOOL_MODE))
  97     {
  98     DEBUG(D_any) debug_printf("failed setting perms on %s\n", temp_name);
  99     (void) close(fd); fd = -1;
 100     Uunlink(temp_name);
 101     }
 102
 103 return fd;
 104 }
 105
 106
 107
 108 static const uschar *
 109 zap_newlines(const uschar *s)
 110 {
 111 uschar *z, *p;
 112
 113 if (Ustrchr(s, '\n') == NULL) return s;
 114
 115 p = z = string_copy(s);
 116 while ((p = Ustrchr(p, '\n')) != NULL) *p++ = ' ';
 117 return z;
 118 }
 119
 120 static void
 121 spool_var_write(FILE * fp, const uschar * name, const uschar * val)
 122 {
 123 putc('-', fp);
 124 if (is_tainted(val))
 125   {
 126   int q = quoter_for_address(val);
 127   putc('-', fp);
 128   if (is_real_quoter(q)) fprintf(fp, "(%s)", lookup_list[q]->name);
 129   }
 130 fprintf(fp, "%s %s\n", name, val);
 131 }
 132
 133 /*************************************************
 134 *          Write the header spool file           *
 135 *************************************************/
 136
 137 /* Returns the size of the file for success; zero for failure. The file is
 138 written under a temporary name, and then renamed. It's done this way so that it
 139 works with re-writing the file on message deferral as well as for the initial
 140 write. Whenever this function is called, the data file for the message should
 141 be open and locked, thus preventing any other exim process from working on this
 142 message.
 143
 144 Argument:
 145   id      the message id
 146   where   SW_RECEIVING, SW_DELIVERING, or SW_MODIFYING
 147   errmsg  where to put an error message; if NULL, panic-die on error
 148
 149 Returns:  the size of the header texts on success;
 150           negative on writing failure, unless errmsg == NULL
 151 */
 152
 153 int
 154 spool_write_header(uschar *id, int where, uschar **errmsg)
 155 {
 156 int fd;
 157 int size_correction;
 158 FILE * fp;
 159 struct stat statbuf;
 160 uschar * tname;
 161 uschar * fname;
 162
 163 tname = spool_fname(US"input", message_subdir, US"hdr.", message_id);
 164
 165 if ((fd = spool_open_temp(tname)) < 0)
 166   return spool_write_error(where, errmsg, US"open", NULL, NULL);
 167 fp = fdopen(fd, "wb");
 168 DEBUG(D_receive|D_deliver) debug_printf("Writing spool header file: %s\n", tname);
 169
 170 /* We now have an open file to which the header data is to be written. Start
 171 with the file's leaf name, to make the file self-identifying. Continue with the
 172 identity of the submitting user, followed by the sender's address. The sender's
 173 address is enclosed in <> because it might be the null address. Then write the
 174 received time and the number of warning messages that have been sent. */
 175
 176 fprintf(fp, "%s-H\n", message_id);
 177 fprintf(fp, "%.63s %ld %ld\n", originator_login, (long int)originator_uid,
 178   (long int)originator_gid);
 179 fprintf(fp, "<%s>\n", sender_address);
 180 fprintf(fp, "%d %d\n", (int)received_time.tv_sec, warning_count);
 181
 182 fprintf(fp, "-received_time_usec .%06d\n", (int)received_time.tv_usec);
 183 fprintf(fp, "-received_time_complete %d.%06d\n",
 184   (int)received_time_complete.tv_sec, (int)received_time_complete.tv_usec);
 185
 186 /* If there is information about a sending host, remember it. The HELO
 187 data can be set for local SMTP as well as remote. */
 188
 189 if (sender_helo_name) spool_var_write(fp, US"helo_name", sender_helo_name);
 190
 191 if (sender_host_address)
 192   {
 193   if (is_tainted(sender_host_address)) putc('-', fp);
 194   fprintf(fp, "-host_address %s.%d\n", sender_host_address, sender_host_port);
 195   if (sender_host_name)
 196     spool_var_write(fp, US"host_name", sender_host_name);
 197   }
 198 if (sender_host_authenticated)
 199   spool_var_write(fp, US"host_auth", sender_host_authenticated);
 200 if (sender_host_auth_pubname)
 201   spool_var_write(fp, US"host_auth_pubname", sender_host_auth_pubname);
 202
 203 /* Also about the interface a message came in on */
 204
 205 if (interface_address)
 206   {
 207   if (is_tainted(interface_address)) putc('-', fp);
 208   fprintf(fp, "-interface_address %s.%d\n", interface_address, interface_port);
 209   }
 210
 211 if (smtp_active_hostname != primary_hostname)
 212   spool_var_write(fp, US"active_hostname", smtp_active_hostname);
 213
 214 /* Likewise for any ident information; for local messages this is
 215 likely to be the same as originator_login, but will be different if
 216 the originator was root, forcing a different ident. */
 217
 218 if (sender_ident)
 219   spool_var_write(fp, US"ident", sender_ident);
 220
 221 /* Ditto for the received protocol */
 222
 223 if (received_protocol)
 224   spool_var_write(fp, US"received_protocol", received_protocol);
 225
 226 /* Preserve any ACL variables that are set. */
 227
 228 tree_walk(acl_var_c, &acl_var_write, fp);
 229 tree_walk(acl_var_m, &acl_var_write, fp);
 230
 231 /* Now any other data that needs to be remembered. */
 232
 233 if (*debuglog_name)
 234   {
 235   fprintf(fp, "-debug_selector 0x%x\n", debug_selector);
 236   fprintf(fp, "-debuglog_name %s\n", debuglog_name);
 237   }
 238
 239 if (f.spool_file_wireformat)
 240   fprintf(fp, "-spool_file_wireformat\n");
 241 else
 242   fprintf(fp, "-body_linecount %d\n", body_linecount);
 243 fprintf(fp, "-max_received_linelength %d\n", max_received_linelength);
 244
 245 if (body_zerocount > 0) fprintf(fp, "-body_zerocount %d\n", body_zerocount);
 246
 247 if (authenticated_id)
 248   spool_var_write(fp, US"auth_id", authenticated_id);
 249 if (authenticated_sender)
 250   spool_var_write(fp, US"auth_sender", zap_newlines(authenticated_sender));
 251
 252 if (f.allow_unqualified_recipient) fprintf(fp, "-allow_unqualified_recipient\n");
 253 if (f.allow_unqualified_sender) fprintf(fp, "-allow_unqualified_sender\n");
 254 if (f.deliver_firsttime) fprintf(fp, "-deliver_firsttime\n");
 255 if (f.deliver_freeze) fprintf(fp, "-frozen " TIME_T_FMT "\n", deliver_frozen_at);
 256 if (f.dont_deliver) fprintf(fp, "-N\n");
 257 if (host_lookup_deferred) fprintf(fp, "-host_lookup_deferred\n");
 258 if (host_lookup_failed) fprintf(fp, "-host_lookup_failed\n");
 259 if (f.sender_local) fprintf(fp, "-local\n");
 260 if (f.local_error_message) fprintf(fp, "-localerror\n");
 261 #ifdef HAVE_LOCAL_SCAN
 262 if (local_scan_data) spool_var_write(fp, US"local_scan", local_scan_data);
 263 #endif
 264 #ifdef WITH_CONTENT_SCAN
 265 if (spam_bar)       spool_var_write(fp, US"spam_bar",       spam_bar);
 266 if (spam_score)     spool_var_write(fp, US"spam_score",     spam_score);
 267 if (spam_score_int) spool_var_write(fp, US"spam_score_int", spam_score_int);
 268 #endif
 269 if (f.deliver_manual_thaw) fprintf(fp, "-manual_thaw\n");
 270 if (f.sender_set_untrusted) fprintf(fp, "-sender_set_untrusted\n");
 271
 272 #ifdef EXPERIMENTAL_BRIGHTMAIL
 273 if (bmi_verdicts) spool_var_write(fp, US"bmi_verdicts", bmi_verdicts);
 274 #endif
 275
 276 #ifndef DISABLE_TLS
 277 if (tls_in.certificate_verified) fprintf(fp, "-tls_certificate_verified\n");
 278 if (tls_in.cipher) spool_var_write(fp, US"tls_cipher", tls_in.cipher);
 279 if (tls_in.peercert)
 280   {
 281   if (tls_export_cert(big_buffer, big_buffer_size, tls_in.peercert))
 282     fprintf(fp, "--tls_peercert %s\n", CS big_buffer);
 283   }
 284 if (tls_in.peerdn)       spool_var_write(fp, US"tls_peerdn", string_printing(tls_in.peerdn));
 285 if (tls_in.sni)          spool_var_write(fp, US"tls_sni",    string_printing(tls_in.sni));
 286 if (tls_in.ourcert)
 287   {
 288   if (tls_export_cert(big_buffer, big_buffer_size, tls_in.ourcert))
 289     fprintf(fp, "-tls_ourcert %s\n", CS big_buffer);
 290   }
 291 if (tls_in.ocsp)         fprintf(fp, "-tls_ocsp %d\n",   tls_in.ocsp);
 292 # ifndef DISABLE_TLS_RESUME
 293 fprintf(fp, "-tls_resumption %c\n", 'A' + tls_in.resumption);
 294 # endif
 295 if (tls_in.ver) spool_var_write(fp, US"tls_ver", tls_in.ver);
 296 #endif
 297
 298 #ifdef SUPPORT_I18N
 299 if (message_smtputf8)
 300   {
 301   fprintf(fp, "-smtputf8\n");
 302   if (message_utf8_downconvert)
 303     fprintf(fp, "-utf8_%sdowncvt\n", message_utf8_downconvert < 0 ? "opt" : "");
 304   }
 305 #endif
 306
 307 /* Write the dsn flags to the spool header file */
 308 /* DEBUG(D_deliver) debug_printf("DSN: Write SPOOL: -dsn_envid %s\n", dsn_envid); */
 309 if (dsn_envid) fprintf(fp, "-dsn_envid %s\n", dsn_envid);
 310 /* DEBUG(D_deliver) debug_printf("DSN: Write SPOOL: -dsn_ret %d\n", dsn_ret); */
 311 if (dsn_ret) fprintf(fp, "-dsn_ret %d\n", dsn_ret);
 312
 313 /* To complete the envelope, write out the tree of non-recipients, followed by
 314 the list of recipients. These won't be disjoint the first time, when no
 315 checking has been done. If a recipient is a "one-time" alias, it is followed by
 316 a space and its parent address number (pno). */
 317
 318 tree_write(tree_nonrecipients, fp);
 319 fprintf(fp, "%d\n", recipients_count);
 320 for (int i = 0; i < recipients_count; i++)
 321   {
 322   recipient_item *r = recipients_list + i;
 323   const uschar *address = zap_newlines(r->address);
 324
 325   /* DEBUG(D_deliver) debug_printf("DSN: Flags: 0x%x\n", r->dsn_flags); */
 326
 327   if (r->pno < 0 && !r->errors_to && r->dsn_flags == 0)
 328     fprintf(fp, "%s\n", address);
 329   else
 330     {
 331     const uschar *errors_to = r->errors_to ? zap_newlines(r->errors_to) : CUS"";
 332     /* for DSN SUPPORT extend exim 4 spool in a compatible way by
 333     adding new values upfront and add flag 0x02 */
 334     const uschar *orcpt = r->orcpt ? zap_newlines(r->orcpt) : CUS"";
 335
 336     fprintf(fp, "%s %s %d,%d %s %d,%d#3\n", address, orcpt, Ustrlen(orcpt),
 337       r->dsn_flags, errors_to, Ustrlen(errors_to), r->pno);
 338     }
 339
 340     DEBUG(D_deliver) debug_printf("DSN: **** SPOOL_OUT - "
 341       "address: <%s> errorsto: <%s> orcpt: <%s> dsn_flags: 0x%x\n",
 342       r->address, r->errors_to, r->orcpt, r->dsn_flags);
 343   }
 344
 345 /* Put a blank line before the headers */
 346
 347 fprintf(fp, "\n");
 348
 349 /* Save the size of the file so far so we can subtract it from the final length
 350 to get the actual size of the headers. */
 351
 352 fflush(fp);
 353 if (fstat(fd, &statbuf))
 354   return spool_write_error(where, errmsg, US"fstat", tname, fp);
 355 size_correction = statbuf.st_size;
 356
 357 /* Finally, write out the message's headers. To make it easier to read them
 358 in again, precede each one with the count of its length. Make the count fixed
 359 length to aid human eyes when debugging and arrange for it not be included in
 360 the size. It is followed by a space for normal headers, a flagging letter for
 361 various other headers, or an asterisk for old headers that have been rewritten.
 362 These are saved as a record for debugging. Don't included them in the message's
 363 size. */
 364
 365 for (header_line * h = header_list; h; h = h->next)
 366   {
 367   fprintf(fp, "%03d%c %s", h->slen, h->type, h->text);
 368   size_correction += 5;
 369   if (h->type == '*') size_correction += h->slen;
 370   }
 371
 372 /* Flush and check for any errors while writing */
 373
 374 if (fflush(fp) != 0 || ferror(fp))
 375   return spool_write_error(where, errmsg, US"write", tname, fp);
 376
 377 /* Force the file's contents to be written to disk. Note that fflush()
 378 just pushes it out of C, and fclose() doesn't guarantee to do the write
 379 either. That's just the way Unix works... */
 380
 381 if (EXIMfsync(fileno(fp)) < 0)
 382   return spool_write_error(where, errmsg, US"sync", tname, fp);
 383
 384 /* Get the size of the file, and close it. */
 385
 386 if (fstat(fd, &statbuf) != 0)
 387   return spool_write_error(where, errmsg, US"fstat", tname, NULL);
 388 if (fclose(fp) != 0)
 389   return spool_write_error(where, errmsg, US"close", tname, NULL);
 390
 391 /* Rename the file to its correct name, thereby replacing any previous
 392 incarnation. */
 393
 394 fname = spool_fname(US"input", message_subdir, id, US"-H");
 395 DEBUG(D_receive|D_deliver) debug_printf("Renaming spool header file: %s\n", fname);
 396
 397 if (Urename(tname, fname) < 0)
 398   return spool_write_error(where, errmsg, US"rename", tname, NULL);
 399
 400 /* Linux (and maybe other OS?) does not automatically sync a directory after
 401 an operation like rename. We therefore have to do it forcibly ourselves in
 402 these cases, to make sure the file is actually accessible on disk, as opposed
 403 to just the data being accessible from a file in lost+found. Linux also has
 404 O_DIRECTORY, for opening a directory.
 405
 406 However, it turns out that some file systems (some versions of NFS?) do not
 407 support directory syncing. It seems safe enough to ignore EINVAL to cope with
 408 these cases. One hack on top of another... but that's life. */
 409
 410 #ifdef NEED_SYNC_DIRECTORY
 411
 412 tname = spool_fname(US"input", message_subdir, US".", US"");
 413
 414 # ifndef O_DIRECTORY
 415 #  define O_DIRECTORY 0
 416 # endif
 417
 418 if ((fd = Uopen(tname, O_RDONLY|O_DIRECTORY, 0)) < 0)
 419   return spool_write_error(where, errmsg, US"directory open", fname, NULL);
 420
 421 if (EXIMfsync(fd) < 0 && errno != EINVAL)
 422   return spool_write_error(where, errmsg, US"directory sync", fname, NULL);
 423
 424 if (close(fd) < 0)
 425   return spool_write_error(where, errmsg, US"directory close", fname, NULL);
 426
 427 #endif  /* NEED_SYNC_DIRECTORY */
 428
 429 /* Return the number of characters in the headers, which is the file size, less
 430 the preliminary stuff, less the additional count fields on the headers. */
 431
 432 DEBUG(D_receive) debug_printf("Size of headers = %d\n",
 433   (int)(statbuf.st_size - size_correction));
 434
 435 return statbuf.st_size - size_correction;
 436 }
 437
 438
 439 /************************************************
 440 *              Make a hard link                 *
 441 ************************************************/
 442
 443 /* Used by spool_move_message() below. Note re the use of sprintf(): the value
 444 of spool_directory is checked to ensure that it is less than 200 characters at
 445 start-up time.
 446
 447 Arguments:
 448   dir        base directory name
 449   dq         destiinationqueue name
 450   subdir     subdirectory name
 451   id         message id
 452   suffix     suffix to add to id
 453   from       source directory prefix
 454   to         destination directory prefix
 455   noentok    if TRUE, absence of file is not an error
 456
 457 Returns:     TRUE if all went well
 458              FALSE, having panic logged if not
 459 */
 460
 461 static BOOL
 462 make_link(uschar *dir, uschar * dq, uschar *subdir, uschar *id, uschar *suffix,
 463   uschar *from, uschar *to, BOOL noentok)
 464 {
 465 uschar * fname = spool_fname(string_sprintf("%s%s", from, dir), subdir, id, suffix);
 466 uschar * tname = spool_q_fname(string_sprintf("%s%s", to,   dir), dq, subdir, id, suffix);
 467 if (Ulink(fname, tname) < 0 && (!noentok || errno != ENOENT))
 468   {
 469   log_write(0, LOG_MAIN|LOG_PANIC, "link(\"%s\", \"%s\") failed while moving "
 470     "message: %s", fname, tname, strerror(errno));
 471   return FALSE;
 472   }
 473 return TRUE;
 474 }
 475
 476
 477
 478 /************************************************
 479 *                Break a link                   *
 480 ************************************************/
 481
 482 /* Used by spool_move_message() below. Note re the use of sprintf(): the value
 483 of spool_directory is checked to ensure that it is less than 200 characters at
 484 start-up time.
 485
 486 Arguments:
 487   dir        base directory name
 488   subdir     subdirectory name
 489   id         message id
 490   suffix     suffix to add to id
 491   from       source directory prefix
 492   noentok    if TRUE, absence of file is not an error
 493
 494 Returns:     TRUE if all went well
 495              FALSE, having panic logged if not
 496 */
 497
 498 static BOOL
 499 break_link(uschar *dir, uschar *subdir, uschar *id, uschar *suffix, uschar *from,
 500   BOOL noentok)
 501 {
 502 uschar * fname = spool_fname(string_sprintf("%s%s", from, dir), subdir, id, suffix);
 503 if (Uunlink(fname) < 0 && (!noentok || errno != ENOENT))
 504   {
 505   log_write(0, LOG_MAIN|LOG_PANIC, "unlink(\"%s\") failed while moving "
 506     "message: %s", fname, strerror(errno));
 507   return FALSE;
 508   }
 509 return TRUE;
 510 }
 511
 512
 513
 514 /************************************************
 515 *            Move message files                 *
 516 ************************************************/
 517
 518 /* Move the files for a message (-H, -D, and msglog) from one directory (or
 519 hierarchy) to another. It is assume that there is no -J file in existence when
 520 this is done.
 521
 522 Arguments:
 523   id          the id of the message to be delivered
 524   subdir      the subdirectory name, or an empty string
 525   from        a prefix for "input" or "msglog" for where the message is now
 526   to          a prefix for "input" or "msglog" for where the message is to go
 527
 528 Returns:      TRUE if all is well
 529               FALSE if not, with error logged in panic and main logs
 530 */
 531
 532 BOOL
 533 spool_move_message(uschar *id, uschar *subdir, uschar *from, uschar *to)
 534 {
 535 uschar * dest_qname = queue_name_dest ? queue_name_dest : queue_name;
 536
 537 /* Since we are working within the spool, de-taint the dest queue name */
 538 dest_qname = string_copy_taint(dest_qname, GET_UNTAINTED);
 539
 540 /* Create any output directories that do not exist. */
 541
 542 (void) directory_make(spool_directory,
 543   spool_q_sname(string_sprintf("%sinput", to), dest_qname, subdir),
 544   INPUT_DIRECTORY_MODE, TRUE);
 545 (void) directory_make(spool_directory,
 546   spool_q_sname(string_sprintf("%smsglog", to), dest_qname, subdir),
 547   INPUT_DIRECTORY_MODE, TRUE);
 548
 549 /* Move the message by first creating new hard links for all the files, and
 550 then removing the old links. When moving messages onto the main spool, the -H
 551 file should be set up last, because that's the one that tells Exim there is a
 552 message to be delivered, so we create its new link last and remove its old link
 553 first. Programs that look at the alternate directories should follow the same
 554 rule of waiting for a -H file before doing anything. When moving messages off
 555 the mail spool, the -D file should be open and locked at the time, thus keeping
 556 Exim's hands off. */
 557
 558 if (!make_link(US"msglog", dest_qname, subdir, id, US"", from, to, TRUE) ||
 559     !make_link(US"input",  dest_qname, subdir, id, US"-D", from, to, FALSE) ||
 560     !make_link(US"input",  dest_qname, subdir, id, US"-H", from, to, FALSE))
 561   return FALSE;
 562
 563 if (!break_link(US"input",  subdir, id, US"-H", from, FALSE) ||
 564     !break_link(US"input",  subdir, id, US"-D", from, FALSE) ||
 565     !break_link(US"msglog", subdir, id, US"", from, TRUE))
 566   return FALSE;
 567
 568 log_write(0, LOG_MAIN, "moved from %s%s%s%sinput, %smsglog to %s%s%s%sinput, %smsglog",
 569    *queue_name?"(":"", *queue_name?queue_name:US"", *queue_name?") ":"",
 570    from, from,
 571    *dest_qname?"(":"", *dest_qname?dest_qname:US"", *dest_qname?") ":"",
 572    to, to);
 573
 574 return TRUE;
 575 }
 576
 577
 578 /* End of spool_out.c */
 579 /* vi: aw ai sw=2
 580 */