src/src/transports/queuefile.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) Andrew Colin Kissa <andrew@topdog.za.net> 2016 */
   6 /* Copyright (c) University of Cambridge 2016 */
   7 /* Copyright (c) The Exim Maintainers 1995 - 2018 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   9
  10
  11 #include "../exim.h"
  12 #include "queuefile.h"
  13
  14 /* Options specific to the appendfile transport. They must be in alphabetic
  15 order (note that "_" comes before the lower case letters). Some of them are
  16 stored in the publicly visible instance block - these are flagged with the
  17 opt_public flag. */
  18
  19 optionlist queuefile_transport_options[] = {
  20   { "directory", opt_stringptr,
  21     (void *)offsetof(queuefile_transport_options_block, dirname) },
  22 };
  23
  24
  25 /* Size of the options list. An extern variable has to be used so that its
  26 address can appear in the tables drtables.c. */
  27
  28 int queuefile_transport_options_count =
  29   sizeof(queuefile_transport_options) / sizeof(optionlist);
  30
  31
  32 #ifdef MACRO_PREDEF
  33
  34 /* Dummy values */
  35 queuefile_transport_options_block queuefile_transport_option_defaults = {0};
  36 void queuefile_transport_init(transport_instance *tblock) {}
  37 BOOL queuefile_transport_entry(transport_instance *tblock, address_item *addr) {return FALSE;}
  38
  39 #else   /*!MACRO_PREDEF*/
  40
  41
  42
  43 /* Default private options block for the appendfile transport. */
  44
  45 queuefile_transport_options_block queuefile_transport_option_defaults = {
  46   NULL,           /* dirname */
  47 };
  48
  49 /*************************************************
  50 *          Initialization entry point            *
  51 *************************************************/
  52
  53 void queuefile_transport_init(transport_instance *tblock)
  54 {
  55 queuefile_transport_options_block *ob =
  56   (queuefile_transport_options_block *) tblock->options_block;
  57
  58 if (!ob->dirname)
  59   log_write(0, LOG_PANIC_DIE | LOG_CONFIG,
  60     "directory must be set for the %s transport", tblock->name);
  61 }
  62
  63 /* This function will copy from a file to another
  64
  65 Arguments:
  66   dst        fd to write to (the destination queue file)
  67   src        fd to read from (the spool queue file)
  68
  69 Returns:       TRUE if all went well, FALSE otherwise with errno set
  70 */
  71
  72 static BOOL
  73 copy_spool_file(int dst, int src)
  74 {
  75 int i, j;
  76 uschar buffer[16384];
  77 uschar * s;
  78
  79 if (lseek(src, 0, SEEK_SET) != 0)
  80   return FALSE;
  81
  82 do
  83   if ((j = read(src, buffer, sizeof(buffer))) > 0)
  84     for (s = buffer; (i = write(dst, s, j)) != j; s += i, j -= i)
  85       if (i < 0)
  86         return FALSE;
  87   else if (j < 0)
  88     return FALSE;
  89 while (j > 0);
  90 return TRUE;
  91 }
  92
  93 /* This function performs the actual copying of the header
  94 and data files to the destination directory
  95
  96 Arguments:
  97   tb            the transport block
  98   addr          address_item being processed
  99   dstpath       destination directory name
 100   sdfd          int Source directory fd
 101   ddfd          int Destination directory fd
 102   link_file     BOOL use linkat instead of data copy
 103   srcfd         fd for data file, or -1 for header file
 104
 105 Returns:       TRUE if all went well, FALSE otherwise
 106 */
 107
 108 static BOOL
 109 copy_spool_files(transport_instance * tb, address_item * addr,
 110   const uschar * dstpath, int sdfd, int ddfd, BOOL link_file, int srcfd)
 111 {
 112 BOOL is_hdr_file = srcfd < 0;
 113 const uschar * suffix = srcfd < 0 ? US"H" : US"D";
 114 int dstfd;
 115 const uschar * filename = string_sprintf("%s-%s", message_id, suffix);
 116 const uschar * srcpath = spool_fname(US"input", message_subdir, message_id, suffix);
 117 const uschar * s, * op;
 118
 119 dstpath = string_sprintf("%s/%s-%s", dstpath, message_id, suffix);
 120
 121 if (link_file)
 122   {
 123   DEBUG(D_transport) debug_printf("%s transport, linking %s => %s\n",
 124     tb->name, srcpath, dstpath);
 125
 126   if (linkat(sdfd, CCS filename, ddfd, CCS filename, 0) >= 0)
 127     return TRUE;
 128
 129   op = US"linking";
 130   s = dstpath;
 131   }
 132 else                                    /* use data copy */
 133   {
 134   DEBUG(D_transport) debug_printf("%s transport, copying %s => %s\n",
 135     tb->name, srcpath, dstpath);
 136
 137   if (  (s = dstpath,
 138          (dstfd = openat(ddfd, CCS filename, O_RDWR|O_CREAT|O_EXCL, SPOOL_MODE))
 139          < 0
 140         )
 141      ||    is_hdr_file
 142         && (s = srcpath, (srcfd = openat(sdfd, CCS filename, O_RDONLY)) < 0)
 143      )
 144     op = US"opening";
 145
 146   else
 147     if (s = dstpath, fchmod(dstfd, SPOOL_MODE) != 0)
 148       op = US"setting perms on";
 149     else
 150       if (!copy_spool_file(dstfd, srcfd))
 151         op = US"creating";
 152       else
 153         return TRUE;
 154   }
 155
 156 addr->basic_errno = errno;
 157 addr->message = string_sprintf("%s transport %s file: %s failed with error: %s",
 158   tb->name, op, s, strerror(errno));
 159 addr->transport_return = DEFER;
 160 return FALSE;
 161 }
 162
 163 /*************************************************
 164 *              Main entry point                  *
 165 *************************************************/
 166
 167 /* This transport always returns FALSE, indicating that the status in
 168 the first address is the status for all addresses in a batch. */
 169
 170 BOOL
 171 queuefile_transport_entry(transport_instance * tblock, address_item * addr)
 172 {
 173 queuefile_transport_options_block * ob =
 174   (queuefile_transport_options_block *) tblock->options_block;
 175 BOOL can_link;
 176 uschar * sourcedir = spool_dname(US"input", message_subdir);
 177 uschar * s, * dstdir;
 178 struct stat dstatbuf, sstatbuf;
 179 int ddfd = -1, sdfd = -1;
 180
 181 DEBUG(D_transport)
 182   debug_printf("%s transport entered\n", tblock->name);
 183
 184 #ifndef O_DIRECTORY
 185 # define O_DIRECTORY 0
 186 #endif
 187 #ifndef O_NOFOLLOW
 188 # define O_NOFOLLOW 0
 189 #endif
 190
 191 if (!(dstdir = expand_string(ob->dirname)))
 192   {
 193   addr->message = string_sprintf("%s transport: failed to expand dirname option",
 194     tblock->name);
 195   addr->transport_return = DEFER;
 196   return FALSE;
 197   }
 198 if (*dstdir != '/')
 199   {
 200   addr->transport_return = PANIC;
 201   addr->message = string_sprintf("%s transport directory: "
 202     "%s is not absolute", tblock->name, dstdir);
 203   return FALSE;
 204   }
 205
 206 /* Open the source and destination directories and check if they are
 207 on the same filesystem, so we can hard-link files rather than copying. */
 208
 209 if (  (s = dstdir,
 210        (ddfd = Uopen(s, O_RDONLY | O_DIRECTORY | O_NOFOLLOW, 0)) < 0)
 211    || (s = sourcedir,
 212        (sdfd = Uopen(sourcedir, O_RDONLY | O_DIRECTORY | O_NOFOLLOW, 0)) < 0)
 213    )
 214   {
 215   addr->transport_return = PANIC;
 216   addr->basic_errno = errno;
 217   addr->message = string_sprintf("%s transport accessing directory: %s "
 218     "failed with error: %s", tblock->name, s, strerror(errno));
 219   if (ddfd >= 0) (void) close(ddfd);
 220   return FALSE;
 221   }
 222
 223 if (  (s = dstdir,    fstat(ddfd, &dstatbuf) < 0)
 224    || (s = sourcedir, fstat(sdfd, &sstatbuf) < 0)
 225    )
 226   {
 227   addr->transport_return = PANIC;
 228   addr->basic_errno = errno;
 229   addr->message = string_sprintf("%s transport fstat on directory fd: "
 230     "%s failed with error: %s", tblock->name, s, strerror(errno));
 231   goto RETURN;
 232   }
 233 can_link = (dstatbuf.st_dev == sstatbuf.st_dev);
 234
 235 if (dont_deliver)
 236   {
 237   DEBUG(D_transport)
 238     debug_printf("*** delivery by %s transport bypassed by -N option\n",
 239       tblock->name);
 240   addr->transport_return = OK;
 241   goto RETURN;
 242   }
 243
 244 /* Link or copy the header and data spool files */
 245
 246 DEBUG(D_transport)
 247   debug_printf("%s transport, copying header file\n", tblock->name);
 248
 249 if (!copy_spool_files(tblock, addr, dstdir, sdfd, ddfd, can_link, -1))
 250   goto RETURN;
 251
 252 DEBUG(D_transport)
 253   debug_printf("%s transport, copying data file\n", tblock->name);
 254
 255 if (!copy_spool_files(tblock, addr, dstdir, sdfd, ddfd, can_link,
 256         deliver_datafile))
 257   {
 258   DEBUG(D_transport)
 259     debug_printf("%s transport, copying data file failed, "
 260       "unlinking the header file\n", tblock->name);
 261   Uunlink(string_sprintf("%s/%s-H", dstdir, message_id));
 262   goto RETURN;
 263   }
 264
 265 DEBUG(D_transport)
 266   debug_printf("%s transport succeeded\n", tblock->name);
 267
 268 addr->transport_return = OK;
 269
 270 RETURN:
 271 if (ddfd >= 0) (void) close(ddfd);
 272 if (sdfd >= 0) (void) close(sdfd);
 273
 274 /* A return of FALSE means that if there was an error, a common error was
 275 put in the first address of a batch. */
 276 return FALSE;
 277 }
 278
 279 #endif /*!MACRO_PREDEF*/