dma(8): Upgrade to v0.7.
[dragonfly.git] / libexec / dma / local.c
index 9ce4928..6a6407e 100644 (file)
@@ -1,7 +1,46 @@
+/*
+ * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
+ *
+ * This code is derived from software contributed to The DragonFly Project
+ * by Simon 'corecode' Schubert <corecode@fs.ei.tum.de>.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name of The DragonFly Project nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <sys/wait.h>
+
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <limits.h>
 #include <paths.h>
+#include <signal.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <syslog.h>
 
 #include "dma.h"
 
+static int
+create_mbox(const char *name)
+{
+       struct sigaction sa, osa;
+       pid_t child, waitchild;
+       int status;
+       int i;
+       long maxfd;
+       int e;
+       int r = -1;
+
+       /*
+        * We need to enable SIGCHLD temporarily so that waitpid works.
+        */
+       bzero(&sa, sizeof(sa));
+       sa.sa_handler = SIG_DFL;
+       sigaction(SIGCHLD, &sa, &osa);
+
+       do_timeout(100, 0);
+
+       child = fork();
+       switch (child) {
+       case 0:
+               /* child */
+               maxfd = sysconf(_SC_OPEN_MAX);
+               if (maxfd == -1)
+                       maxfd = 1024;   /* what can we do... */
+
+               for (i = 3; i <= maxfd; ++i)
+                       close(i);
+
+               execl(LIBEXEC_PATH "/dma-mbox-create", "dma-mbox-create", name, NULL);
+               syslog(LOG_ERR, "cannot execute "LIBEXEC_PATH"/dma-mbox-create: %m");
+               exit(1);
+
+       default:
+               /* parent */
+               waitchild = waitpid(child, &status, 0);
+
+               e = errno;
+
+               do_timeout(0, 0);
+
+               if (waitchild == -1 && e == EINTR) {
+                       syslog(LOG_ERR, "hung child while creating mbox `%s': %m", name);
+                       break;
+               }
+
+               if (waitchild == -1) {
+                       syslog(LOG_ERR, "child disappeared while creating mbox `%s': %m", name);
+                       break;
+               }
+
+               if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+                       syslog(LOG_ERR, "error creating mbox `%s'", name);
+                       break;
+               }
+
+               /* success */
+               r = 0;
+               break;
+
+       case -1:
+               /* error */
+               syslog(LOG_ERR, "error creating mbox");
+               break;
+       }
+
+       sigaction(SIGCHLD, &osa, NULL);
+
+       return (r);
+}
+
 int
-deliver_local(struct qitem *it, const char **errmsg)
+deliver_local(struct qitem *it)
 {
        char fn[PATH_MAX+1];
        char line[1000];
        const char *sender;
        const char *newline = "\n";
        size_t linelen;
+       int tries = 0;
        int mbox;
        int error;
        int hadnl = 0;
@@ -29,12 +142,43 @@ deliver_local(struct qitem *it, const char **errmsg)
                return (1);
        }
 
-       /* mailx removes users mailspool file if empty, so open with O_CREAT */
-       mbox = open_locked(fn, O_WRONLY|O_APPEND|O_NONBLOCK|O_CREAT, 0660);
+retry:
+       /* wait for a maximum of 100s to get the lock to the file */
+       do_timeout(100, 0);
+
+       /* don't use O_CREAT here, because we might be running as the wrong user. */
+       mbox = open_locked(fn, O_WRONLY|O_APPEND);
        if (mbox < 0) {
-               syslog(LOG_NOTICE, "local delivery deferred: can not open `%s': %m", fn);
+               int e = errno;
+
+               do_timeout(0, 0);
+
+               switch (e) {
+               case EACCES:
+               case ENOENT:
+                       /*
+                        * The file does not exist or we can't access it.
+                        * Call dma-mbox-create to create it and fix permissions.
+                        */
+                       if (tries > 0 || create_mbox(it->addr) != 0) {
+                               syslog(LOG_ERR, "local delivery deferred: can not create `%s'", fn);
+                               return (1);
+                       }
+                       ++tries;
+                       goto retry;
+
+               case EINTR:
+                       syslog(LOG_NOTICE, "local delivery deferred: can not lock `%s'", fn);
+                       break;
+
+               default:
+                       syslog(LOG_NOTICE, "local delivery deferred: can not open `%s': %m", fn);
+                       break;
+               }
                return (1);
        }
+       do_timeout(0, 0);
+
        mboxlen = lseek(mbox, 0, SEEK_END);
 
        /* New mails start with \nFrom ...., unless we're at the beginning of the mbox */
@@ -48,13 +192,13 @@ deliver_local(struct qitem *it, const char **errmsg)
 
        if (fseek(it->mailf, 0, SEEK_SET) != 0) {
                syslog(LOG_NOTICE, "local delivery deferred: can not seek: %m");
-               return (1);
+               goto out;
        }
 
        error = snprintf(line, sizeof(line), "%sFrom %s\t%s", newline, sender, ctime(&now));
        if (error < 0 || (size_t)error >= sizeof(line)) {
                syslog(LOG_NOTICE, "local delivery deferred: can not write header: %m");
-               return (1);
+               goto out;
        }
        if (write(mbox, line, error) != error)
                goto wrerror;
@@ -65,12 +209,22 @@ deliver_local(struct qitem *it, const char **errmsg)
                linelen = strlen(line);
                if (linelen == 0 || line[linelen - 1] != '\n') {
                        syslog(LOG_CRIT, "local delivery failed: corrupted queue file");
-                       *errmsg = "corrupted queue file";
+                       snprintf(errmsg, sizeof(errmsg), "corrupted queue file");
                        error = -1;
                        goto chop;
                }
 
-               if (hadnl && strncmp(line, "From ", 5) == 0) {
+               /*
+                * mboxro processing:
+                * - escape lines that start with "From " with a > sign.
+                * - be reversable by escaping lines that contain an arbitrary
+                *   number of > signs, followed by "From ", i.e. />*From / in regexp.
+                * - strict mbox processing only requires escaping after empty lines,
+                *   yet most MUAs seem to relax this requirement and will treat any
+                *   line starting with "From " as the beginning of a new mail.
+                */
+               if ((!MBOX_STRICT || hadnl) &&
+                   strncmp(&line[strspn(line, ">")], "From ", 5) == 0) {
                        const char *gt = ">";
 
                        if (write(mbox, gt, 1) != 1)
@@ -93,6 +247,7 @@ wrerror:
 chop:
        if (ftruncate(mbox, mboxlen) != 0)
                syslog(LOG_WARNING, "error recovering mbox `%s': %m", fn);
+out:
        close(mbox);
        return (error);
 }