path: root/camel/camel-movemail.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* camel-movemail.c: mbox copying function */

/*
 * Author:
 *  Dan Winship <danw@helixcode.com>
 *
 * Copyright 2000 Helix Code, Inc. (http://www.helixcode.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */

#include <config.h>

#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>

#include "camel-movemail.h"
#include "camel-exception.h"

/**
 * camel_movemail: Copy an mbox file from a shared spool directory to a
 * new folder in a Camel store
 * @source: source file
 * @dest: destination file
 * @ex: a CamelException
 *
 * This copies an mbox file from a shared directory with multiple
 * readers and writers into a private (presumably Camel-controlled)
 * directory. Dot locking is used on the source file (but not the
 * destination).
 *
 * Return value: 1 if mail was copied, 0 if the source file contained
 * no mail, -1 if an error occurred.
 **/
int
camel_movemail (const char *source, const char *dest, CamelException *ex)
{
    gboolean locked, error;
    int sfd, dfd, tmpfd;
    char *locktmpfile, *lockfile;
    struct stat st;
    time_t now, timeout;
    int nread, nwrote;
    char buf[BUFSIZ];

    camel_exception_clear (ex);

    /* Stat and then open the spool file. If it doesn't exist or
     * is empty, the user has no mail. (There's technically a race
     * condition here in that an MDA might have just now locked it
     * to deliver a message, but we don't care. In that case,
     * assuming it's unlocked is equivalent to pretending we were
     * called a fraction earlier.)
     */
    if (stat (source, &st) == -1) {
        if (errno == ENOENT)
            return 0;

        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                      "Could not check mail file %s: %s",
                      source, g_strerror (errno));
        return -1;
    }
    if (st.st_size == 0)
        return 0;

    sfd = open (source, O_RDWR);
    if (sfd == -1) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                      "Could not open mail file %s: %s",
                      source, g_strerror (errno));
        return -1;
    }

    dfd = open (dest, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
    if (dfd == -1) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                      "Could not open temporary mail "
                      "file %s: %s", dest, g_strerror (errno));
        close (sfd);
        return -1;
    }

    /* Create the unique lock file. */
    locktmpfile = g_strdup_printf ("%s.lock.XXXXXX", source);
#ifdef HAVE_MKSTEMP
    tmpfd = mkstemp (locktmpfile);
#else
    if (mktemp (locktmpfile)) {
        tmpfd = open (locktmpfile, O_RDWR | O_CREAT | O_EXCL,
                  S_IRUSR | S_IWUSR);
    } else
        tmpfd = -1;
#endif
    if (tmpfd == -1) {
        camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                      "Could not create lock file "
                      "for %s: %s", source, g_strerror (errno));
        close (sfd);
        close (dfd);
        unlink (dest);
        return -1;
    }
    close (tmpfd);

    lockfile = g_strdup_printf ("%s.lock", source);
    locked = FALSE;
    time (&timeout);
    timeout += 30;

    /* Loop trying to lock the file for 30 seconds. */
    while (time (&now) < timeout) {
        /* Try to make the lock. */
        if (symlink (locktmpfile, lockfile) == 0) {
            locked = TRUE;
            break;
        }

        /* If we fail for a reason other than that someone
         * else has the lock, then abort.
         */
        if (errno != EEXIST) {
            camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                          "Could not create lock "
                          "file for %s: %s", source,
                          g_strerror (errno));
            break;
        }

        /* Check the modtime on the lock file. */
        if (stat (lockfile, &st) == -1) {
            /* If the lockfile disappeared, try again. */
            if (errno == ENOENT)
                continue;

            /* Some other error. Abort. */
            camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                          "Could not test lock "
                          "file for %s: %s", source,
                          g_strerror (errno));
            break;
        }

        /* If the lock file is stale, remove it and try again. */
        if (st.st_mtime < now - 60) {
            unlink (lockfile);
            continue;
        }

        /* Otherwise, sleep and try again. */
        sleep (5);
    }

    if (!locked) {
        /* Something has gone awry. */
        if (now >= timeout) {
            camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                          "Timed out trying to get "
                          "lock file on %s. Try again "
                          "later.", source);
        }
        g_free (lockfile);
        unlink (locktmpfile);
        g_free (locktmpfile);
        close (sfd);
        close (dfd);
        unlink (dest);
        return -1;
    }

    /* OK. We have the file locked now. */

    /* FIXME: Set a timer to keep the file locked. */

    error = FALSE;
    while (1) {
        int written = 0;

        nread = read (sfd, buf, sizeof (buf));
        if (nread == 0)
            break;
        else if (nread == -1) {
            camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                          "Error reading mail file: %s",
                          g_strerror (errno));
            error = TRUE;
            break;
        }

        while (nread) {
            nwrote = write (dfd, buf + written, nread);
            if (nwrote == -1) {
                camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                              "Error writing "
                              "mail temp file: %s",
                              g_strerror (errno));
                error = TRUE;
                break;
            }
            written += nwrote;
            nread -= nwrote;
        }
    }

    /* If no errors occurred copying the data, and we successfully
     * close the destination file, then truncate the source file.
     * If there is some sort of error, delete the destination file.
     */
    if (!error) {
        if (close (dfd) == 0)
            ftruncate (sfd, 0);
        else {
            camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
                          "Failed to store mail in "
                          "temp file %s: %s", dest,
                          g_strerror (errno));
            unlink (dest);
            error = TRUE;
        }
    } else {
        close (dfd);
        unlink (dest);
    }
    close (sfd);

    /* Clean up lock files. */
    unlink (lockfile);
    g_free (lockfile);
    unlink (locktmpfile);
    g_free (locktmpfile);

    return error ? -1 : 1;
}