src/lib/file-dotlock.c

	file-dotlock.c revision d6f2a39470b2d0b9e44bd886abacd41e6e1ec2d2
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi/* Copyright (C) 2003 Timo Sirainen */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen#include "lib.h"
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen#include "str.h"
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen#include "hex-binary.h"
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen#include "hostpid.h"
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi#include "randgen.h"
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi#include "write-full.h"
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen#include "file-dotlock.h"
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen#include <stdio.h>
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi#include <stdlib.h>
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen#include <signal.h>
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi#include <time.h>
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi#include <sys/stat.h>
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi#define DEFAULT_LOCK_SUFFIX ".lock"
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi/* 0.1 .. 0.2msec */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi#define LOCK_RANDOM_USLEEP_TIME (100000 + (unsigned int)rand() % 100000)
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvistruct lock_info {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    const char *path, *lock_path, *temp_path;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    unsigned int stale_timeout;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    unsigned int immediate_stale_timeout;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    int fd;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    dev_t dev;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    ino_t ino;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    off_t size;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    time_t ctime, mtime;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    off_t last_size;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    time_t last_ctime, last_mtime;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    time_t last_change;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    pid_t pid;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    time_t last_pid_check;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi};
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvistatic pid_t read_local_pid(const char *lock_path)
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi{
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    char buf[512], *host;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    int fd;
9b5576a265cbadb1f0b3c3d5e40e928e1fed1ec9Timo Sirainen    ssize_t ret;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    fd = open(lock_path, O_RDONLY);
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (fd == -1)
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        return -1; /* ignore the actual error */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    /* read line */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    ret = read(fd, buf, sizeof(buf)-1);
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    (void)close(fd);
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (ret <= 0)
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        return -1;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    /* fix the string */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (buf[ret-1] == '\n')
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        ret--;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    buf[ret] = '\0';
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    /* it should contain pid:host */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    host = strchr(buf, ':');
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (host == NULL)
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        return -1;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    *host++ = '\0';
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    /* host must be ours */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (strcmp(host, my_hostname) != 0)
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        return -1;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (!is_numeric(buf, '\0'))
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        return -1;
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen    return (pid_t)strtoul(buf, NULL, 0);
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi}
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvistatic int check_lock(time_t now, struct lock_info *lock_info)
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi{
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    struct stat st;
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (lstat(lock_info->lock_path, &st) < 0) {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        if (errno != ENOENT) {
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen            i_error("lstat(%s) failed: %m", lock_info->lock_path);
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            return -1;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        }
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        return 1;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    }
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (lock_info->immediate_stale_timeout != 0 &&
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        now > st.st_mtime + (time_t)lock_info->immediate_stale_timeout &&
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        now > st.st_ctime + (time_t)lock_info->immediate_stale_timeout) {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        /* old lock file */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        if (unlink(lock_info->lock_path) < 0 && errno != ENOENT) {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            i_error("unlink(%s) failed: %m", lock_info->lock_path);
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            return -1;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        }
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        return 1;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    }
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (lock_info->stale_timeout == 0) {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        /* no change checking */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        return 0;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    }
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (lock_info->ino != st.st_ino ||
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        !CMP_DEV_T(lock_info->dev, st.st_dev) ||
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        lock_info->ctime != st.st_ctime ||
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        lock_info->mtime != st.st_mtime ||
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        lock_info->size != st.st_size) {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        /* either our first check or someone else got the lock file.
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi           check if it contains a pid whose existence we can verify */
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        lock_info->dev = st.st_dev;
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        lock_info->ino = st.st_ino;
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        lock_info->ctime = st.st_ctime;
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        lock_info->mtime = st.st_mtime;
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        lock_info->size = st.st_size;
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        lock_info->pid = read_local_pid(lock_info->lock_path);
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        lock_info->last_change = now;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    }
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (lock_info->pid != -1) {
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        /* we've local PID. Check if it exists. */
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        if (lock_info->last_pid_check == now)
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen            return 0;
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        if (kill(lock_info->pid, 0) == 0 || errno != ESRCH)
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            return 0;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        /* doesn't exist - go ahead and delete */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        if (unlink(lock_info->lock_path) < 0 && errno != ENOENT) {
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen            i_error("unlink(%s) failed: %m", lock_info->lock_path);
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            return -1;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        }
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        return 1;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    }
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (lock_info->last_change != now) {
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        if (stat(lock_info->path, &st) < 0) {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            if (errno == ENOENT) {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi                /* file doesn't exist. treat it as if
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen                   it hasn't changed */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            } else {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi                i_error("stat(%s) failed: %m", lock_info->path);
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi                return -1;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            }
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        } else if (lock_info->last_size != st.st_size ||
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi               lock_info->last_ctime != st.st_ctime ||
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi               lock_info->last_mtime != st.st_mtime) {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            lock_info->last_change = now;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            lock_info->last_size = st.st_size;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            lock_info->last_ctime = st.st_ctime;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            lock_info->last_mtime = st.st_mtime;
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        }
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    }
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi    if (now > lock_info->last_change + (time_t)lock_info->stale_timeout) {
796beea86bcdc92e4ba2f4865414a951b1717e5cTimo Sirainen        /* no changes for a while, assume stale lock */
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi        if (unlink(lock_info->lock_path) < 0 && errno != ENOENT) {
b28403dc4da6ee942ff18315596b43d4c4e9b7bdMartti Rannanjärvi            i_error("unlink(%s) failed: %m", lock_info->lock_path);
            return -1;
        }
        return 1;
    }

    return 0;
}

static int create_temp_file(const char *prefix, const char **path_r)
{
    string_t *path;
    size_t len;
    struct stat st;
    char randbuf[8];
    int fd;

    path = t_str_new(256);
    str_append(path, prefix);
    len = str_len(path);

    for (;;) {
        do {
            random_fill(randbuf, sizeof(randbuf));
            str_truncate(path, len);
            str_append(path,
                   binary_to_hex(randbuf, sizeof(randbuf)));
            *path_r = str_c(path);
        } while (stat(*path_r, &st) == 0);

        if (errno != ENOENT) {
            i_error("stat(%s) failed: %m", *path_r);
            return -1;
        }

        fd = open(*path_r, O_RDWR | O_EXCL | O_CREAT, 0666);
        if (fd != -1)
            return fd;

        if (errno != EEXIST) {
            i_error("open(%s) failed: %m", *path_r);
            return -1;
        }
    }
}

static int try_create_lock(struct lock_info *lock_info, const char *temp_prefix)
{
    const char *str, *p;

    if (lock_info->temp_path == NULL) {
        /* we'll need our temp file first. */
        if (temp_prefix == NULL) {
            temp_prefix = t_strconcat(".temp.", my_hostname, ".",
                          my_pid, ".", NULL);
        }

        p = *temp_prefix == '/' ? NULL :
            strrchr(lock_info->lock_path, '/');
        if (p != NULL) {
            str = t_strdup_until(lock_info->lock_path, p+1);
            temp_prefix = t_strconcat(str, temp_prefix, NULL);
        }

        lock_info->fd = create_temp_file(temp_prefix, &str);
        if (lock_info->fd == -1)
            return -1;

                lock_info->temp_path = str;
    }

    if (link(lock_info->temp_path, lock_info->lock_path) < 0) {
        if (errno == EEXIST)
            return 0;

        i_error("link(%s, %s) failed: %m",
            lock_info->temp_path, lock_info->lock_path);
        return -1;
    }

    if (unlink(lock_info->temp_path) < 0 && errno != ENOENT) {
        i_error("unlink(%s) failed: %m", lock_info->temp_path);
        /* non-fatal, continue */
    }
    lock_info->temp_path = NULL;

    return 1;
}

static int
dotlock_create(const char *path, const char *temp_prefix,
           const char *lock_suffix, int checkonly, int *fd,
           unsigned int timeout, unsigned int stale_timeout,
           unsigned int immediate_stale_timeout,
           int (*callback)(unsigned int secs_left, int stale,
                   void *context),
           void *context)
{
    const char *lock_path;
        struct lock_info lock_info;
    unsigned int stale_notify_threshold;
    unsigned int change_secs, wait_left;
    time_t now, max_wait_time, last_notify;
    int do_wait, ret;

    now = time(NULL);

    lock_path = t_strconcat(path, lock_suffix, NULL);
    stale_notify_threshold = stale_timeout / 2;
    max_wait_time = now + timeout;

    memset(&lock_info, 0, sizeof(lock_info));
    lock_info.path = path;
    lock_info.lock_path = lock_path;
    lock_info.stale_timeout = stale_timeout;
    lock_info.immediate_stale_timeout = immediate_stale_timeout;
    lock_info.last_change = now;
    lock_info.fd = -1;

    last_notify = 0; do_wait = FALSE;

    do {
        if (do_wait) {
            usleep(LOCK_RANDOM_USLEEP_TIME);
            do_wait = FALSE;
        }

        ret = check_lock(now, &lock_info);
        if (ret < 0)
            break;

        if (ret == 1) {
            if (checkonly)
                break;

            ret = try_create_lock(&lock_info, temp_prefix);
            if (ret != 0)
                break;
        }

        do_wait = TRUE;
        if (last_notify != now && callback != NULL) {
            last_notify = now;
            change_secs = now - lock_info.last_change;
            wait_left = max_wait_time - now;

            t_push();
            if (change_secs >= stale_notify_threshold &&
                change_secs <= wait_left) {
                if (!callback(stale_timeout < change_secs ? 0 :
                          stale_timeout - change_secs,
                          TRUE, context)) {
                    /* we don't want to override */
                    lock_info.last_change = now;
                }
            } else {
                (void)callback(wait_left, FALSE, context);
            }
            t_pop();
        }

        now = time(NULL);
    } while (now < max_wait_time);

    if (ret <= 0 && lock_info.fd != -1) {
        int old_errno = errno;

        (void)close(lock_info.fd);
        lock_info.fd = -1;
        errno = old_errno;
    }
    *fd = lock_info.fd;

    if (ret == 0)
        errno = EAGAIN;
    return ret;
}

int file_lock_dotlock(const char *path, const char *temp_prefix, int checkonly,
              unsigned int timeout, unsigned int stale_timeout,
              unsigned int immediate_stale_timeout,
              int (*callback)(unsigned int secs_left, int stale,
                      void *context),
              void *context, struct dotlock *dotlock_r)
{
    const char *lock_path, *str;
    struct stat st;
    int fd, ret;

    lock_path = t_strconcat(path, DEFAULT_LOCK_SUFFIX, NULL);

    ret = dotlock_create(path, temp_prefix, DEFAULT_LOCK_SUFFIX,
                 checkonly, &fd, timeout, stale_timeout,
                 immediate_stale_timeout, callback, context);
    if (ret <= 0 || checkonly)
        return ret;

    /* write our pid and host, if possible */
    str = t_strdup_printf("%s:%s", my_pid, my_hostname);
    if (write_full(fd, str, strlen(str)) < 0) {
        /* failed, leave it empty then */
        if (ftruncate(fd, 0) < 0) {
            i_error("ftruncate(%s) failed: %m", lock_path);
            (void)close(fd);
            return -1;
        }
    }

    /* save the inode info after writing */
    if (fstat(fd, &st) < 0) {
        i_error("fstat(%s) failed: %m", lock_path);
        (void)close(fd);
        return -1;
    }

    dotlock_r->dev = st.st_dev;
    dotlock_r->ino = st.st_ino;

    if (close(fd) < 0) {
        i_error("fstat(%s) failed: %m", lock_path);
        return -1;
    }

    /* some NFS implementations may have used cached mtime in previous
       fstat() call. Check again to avoid "dotlock was modified" errors. */
    if (stat(lock_path, &st) < 0) {
        i_error("stat(%s) failed: %m", lock_path);
        return -1;
    }
    /* extra sanity check won't hurt.. */
    if (st.st_dev != dotlock_r->dev ||
        st.st_ino != dotlock_r->ino) {
        i_error("dotlock %s was immediately recreated under us",
            lock_path);
        return -1;
    }
    dotlock_r->mtime = st.st_mtime;
    return 1;
}

static int dotlock_delete(const char *path, const char *lock_suffix,
              const struct dotlock *dotlock, int check_mtime)
{
    const char *lock_path;
        struct stat st;

    lock_path = t_strconcat(path, lock_suffix, NULL);

    if (lstat(lock_path, &st) < 0) {
        if (errno == ENOENT) {
            i_warning("Our dotlock file %s was deleted", lock_path);
            return 0;
        }

        i_error("lstat(%s) failed: %m", lock_path);
        return -1;
    }

    if (dotlock->ino != st.st_ino ||
        !CMP_DEV_T(dotlock->dev, st.st_dev)) {
        i_warning("Our dotlock file %s was overridden", lock_path);
        errno = EEXIST;
        return 0;
    }

    if (dotlock->mtime != st.st_mtime && check_mtime) {
        i_warning("Our dotlock file %s was modified (%s vs %s), "
              "assuming it wasn't overridden", lock_path,
              dec2str(dotlock->mtime), dec2str(st.st_mtime));
    }

    if (unlink(lock_path) < 0) {
        if (errno == ENOENT) {
            i_warning("Our dotlock file %s was deleted", lock_path);
            return 0;
        }

        i_error("unlink(%s) failed: %m", lock_path);
        return -1;
    }

    return 1;
}

int file_unlock_dotlock(const char *path, const struct dotlock *dotlock)
{
    return dotlock_delete(path, DEFAULT_LOCK_SUFFIX, dotlock, TRUE);
}

int file_dotlock_open(const char *path,
              const char *temp_prefix, const char *lock_suffix,
              unsigned int timeout, unsigned int stale_timeout,
              unsigned int immediate_stale_timeout,
              int (*callback)(unsigned int secs_left, int stale,
                      void *context),
              void *context)
{
    int ret, fd;

    if (lock_suffix == NULL)
        lock_suffix = DEFAULT_LOCK_SUFFIX;

    ret = dotlock_create(path, temp_prefix, lock_suffix, FALSE, &fd,
                 timeout, stale_timeout, immediate_stale_timeout,
                 callback, context);
    if (ret <= 0)
        return -1;
    return fd;
}

int file_dotlock_replace(const char *path, const char *lock_suffix,
             int fd, int verify_owner)
{
    struct stat st, st2;
    const char *lock_path;
    int old_errno;

    if (lock_suffix == NULL)
        lock_suffix = DEFAULT_LOCK_SUFFIX;

    lock_path = t_strconcat(path, lock_suffix, NULL);
    if (verify_owner) {
        if (fstat(fd, &st) < 0) {
            old_errno = errno;
            i_error("fstat(%s) failed: %m", lock_path);
            (void)close(fd);
            errno = old_errno;
            return -1;
        }
    }
    if (fd != -1) {
        if (close(fd) < 0) {
            i_error("close(%s) failed: %m", lock_path);
            return -1;
        }
    }

    if (verify_owner) {
        if (lstat(lock_path, &st2) < 0) {
            i_error("lstat(%s) failed: %m", lock_path);
            return -1;
        }

        if (st.st_ino != st2.st_ino ||
            !CMP_DEV_T(st.st_dev, st2.st_dev)) {
            i_warning("Our dotlock file %s was overridden",
                  lock_path);
            errno = EEXIST;
            return 0;
        }
    }

    if (rename(lock_path, path) < 0) {
        i_error("rename(%s, %s) failed: %m", lock_path, path);
        return -1;
    }
    return 1;
}

int file_dotlock_delete(const char *path, const char *lock_suffix, int fd)
{
    struct dotlock dotlock;
    struct stat st;
    int old_errno;

    if (lock_suffix == NULL)
        lock_suffix = DEFAULT_LOCK_SUFFIX;

    if (fstat(fd, &st) < 0) {
        old_errno = errno;
        i_error("fstat(%s) failed: %m",
            t_strconcat(path, lock_suffix, NULL));
        (void)close(fd);
        errno = old_errno;
        return -1;
    }

    if (close(fd) < 0) {
        i_error("close(%s) failed: %m",
            t_strconcat(path, lock_suffix, NULL));
        return -1;
    }

    dotlock.dev = st.st_dev;
    dotlock.ino = st.st_ino;
    dotlock.mtime = st.st_mtime;

    return dotlock_delete(path, lock_suffix, &dotlock, FALSE);
}