/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Copyright (C) 2001 Ximian Inc.
*
* Authors: Michael Zucchi <notzed@ximian.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
* License as published by the Free Software Foundation.
*
* 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
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>
#ifdef ENABLE_THREADS
#include <pthread.h>
#endif
#include "camel-exception.h"
#include "camel-lock-helper.h"
#include "camel-lock-client.h"
#define d(x)
/* dunno where this fucking thing is got from */
/* see also camel-lock.c */
#define _(x) (x)
#ifdef ENABLE_THREADS
static pthread_mutex_t lock_lock = PTHREAD_MUTEX_INITIALIZER;
#define LOCK() pthread_mutex_lock(&lock_lock)
#define UNLOCK() pthread_mutex_unlock(&lock_lock)
#else
#define LOCK()
#define UNLOCK()
#endif
static int lock_sequence;
static int lock_helper_pid = -1;
static int lock_stdin_pipe[2], lock_stdout_pipe[2];
static int read_n(int fd, void *buffer, int inlen)
{
char *p = buffer;
int len, left = inlen;
do {
len = read(fd, p, left);
if (len == -1) {
if (errno != EINTR)
return -1;
} else {
left -= len;
p += len;
}
} while (left > 0 && len != 0);
return inlen - left;
}
static int write_n(int fd, void *buffer, int inlen)
{
char *p = buffer;
int len, left = inlen;
do {
len = write(fd, p, left);
if (len == -1) {
if (errno != EINTR)
return -1;
} else {
left -= len;
p += len;
}
} while (left > 0);
return inlen;
}
static int camel_lock_helper_init(CamelException *ex)
{
int i;
if (pipe(lock_stdin_pipe) == -1
|| pipe(lock_stdout_pipe) == -1) {
camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
_("Cannot build locking helper pipe: %s"),
strerror(errno));
return -1;
}
lock_helper_pid = fork();
switch(lock_helper_pid) {
case -1:
close(lock_stdin_pipe[0]);
close(lock_stdin_pipe[1]);
close(lock_stdout_pipe[0]);
close(lock_stdout_pipe[1]);
camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
_("Cannot fork locking helper: %s"),
strerror(errno));
return -1;
case 0:
close(STDIN_FILENO);
dup(lock_stdin_pipe[0]);
close(STDOUT_FILENO);
dup(lock_stdout_pipe[1]);
close(lock_stdin_pipe[0]);
close(lock_stdin_pipe[1]);
close(lock_stdout_pipe[0]);
close(lock_stdout_pipe[1]);
for (i=3;i<255;i++)
close(i);
execl(CAMEL_SBINDIR "/camel-lock-helper", "camel-lock-helper", NULL);
d(fprintf(stderr, "shit, couldn't exec lock helper!\n"));
/* it'll pick this up when it tries to use us */
exit(255);
default:
close(lock_stdin_pipe[0]);
close(lock_stdout_pipe[1]);
/* so the child knows when we vanish */
fcntl(lock_stdin_pipe[1], F_SETFD, FD_CLOEXEC);
fcntl(lock_stdout_pipe[0], F_SETFD, FD_CLOEXEC);
}
return 0;
}
int camel_lock_helper_lock(const char *path, CamelException *ex)
{
struct _CamelLockHelperMsg *msg;
int len = strlen(path);
int res = -1;
int retry = 3;
LOCK();
if (lock_helper_pid == -1) {
if (camel_lock_helper_init(ex) == -1) {
UNLOCK();
return -1;
}
}
msg = alloca(len + sizeof(*msg));
again:
msg->magic = CAMEL_LOCK_HELPER_MAGIC;
msg->seq = lock_sequence;
msg->id = CAMEL_LOCK_HELPER_LOCK;
msg->data = len;
memcpy(msg+1, path, len);
write_n(lock_stdin_pipe[1], msg, len+sizeof(*msg));
do {
/* should also have a timeout here? cancellation? */
len = read_n(lock_stdout_pipe[0], msg, sizeof(*msg));
if (len == 0) {
/* child quit, do we try ressurect it? */
res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
/* if the child exited, this should get it, waidpid returns 0 if the child hasn't */
if (waitpid(lock_helper_pid, NULL, WNOHANG) > 0) {
lock_helper_pid = -1;
close(lock_stdout_pipe[0]);
close(lock_stdin_pipe[1]);
lock_stdout_pipe[0] = -1;
lock_stdin_pipe[1] = -1;
}
goto fail;
}
if (msg->magic != CAMEL_LOCK_HELPER_RETURN_MAGIC
|| msg->seq > lock_sequence) {
res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
d(printf("lock child protocol error\n"));
camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
_("Could not lock '%s': protocol error with lock-helper"), path);
goto fail;
}
} while (msg->seq < lock_sequence);
if (msg->seq == lock_sequence) {
switch(msg->id) {
case CAMEL_LOCK_HELPER_STATUS_OK:
d(printf("lock child locked ok, id is %d\n", msg->data));
res = msg->data;
break;
default:
camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
_("Could not lock '%s'"), path);
d(printf("locking failed ! status = %d\n", msg->id));
break;
}
} else if (retry > 0) {
d(printf("sequence failure, lost message? retry?\n"));
retry--;
goto again;
} else {
camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM,
_("Could not lock '%s': protocol error with lock-helper"), path);
}
fail:
lock_sequence++;
UNLOCK();
return res;
}
int camel_lock_helper_unlock(int lockid)
{
struct _CamelLockHelperMsg *msg;
int res = -1;
int retry = 3;
int len;
d(printf("unlocking lock id %d\n", lockid));
LOCK();
/* impossible to unlock if we haven't locked yet */
if (lock_helper_pid == -1) {
UNLOCK();
return -1;
}
msg = alloca(sizeof(*msg));
again:
msg->magic = CAMEL_LOCK_HELPER_MAGIC;
msg->seq = lock_sequence;
msg->id = CAMEL_LOCK_HELPER_UNLOCK;
msg->data = lockid;
write_n(lock_stdin_pipe[1], msg, sizeof(*msg));
do {
/* should also have a timeout here? cancellation? */
len = read_n(lock_stdout_pipe[0], msg, sizeof(*msg));
if (len == 0) {
/* child quit, do we try ressurect it? */
res = CAMEL_LOCK_HELPER_STATUS_PROTOCOL;
if (waitpid(lock_helper_pid, NULL, WNOHANG) > 0) {
lock_helper_pid = -1;
close(lock_stdout_pipe[0]);
close(lock_stdin_pipe[1]);
lock_stdout_pipe[0] = -1;
lock_stdin_pipe[1] = -1;
}
goto fail;
}
if (msg->magic != CAMEL_LOCK_HELPER_RETURN_MAGIC
|| msg->seq > lock_sequence) {
goto fail;
}
} while (msg->seq < lock_sequence);
if (msg->seq == lock_sequence) {
switch(msg->id) {
case CAMEL_LOCK_HELPER_STATUS_OK:
d(printf("lock child unlocked ok\n"));
res = 0;
break;
default:
d(printf("locking failed ! \n"));
break;
}
} else if (retry > 0) {
d(printf("sequence failure, lost message? retry?\n"));
lock_sequence++;
retry--;
goto again;
}
fail:
lock_sequence++;
UNLOCK();
return res;
}
#if 0
int main(int argc, char **argv)
{
int id1, id2;
d(printf("locking started\n"));
camel_lock_helper_init();
id1 = camel_lock_helper_lock("1 path 1");
if (id1 != -1) {
d(printf("lock ok, unlock\n"));
camel_lock_helper_unlock(id1);
}
id1 = camel_lock_helper_lock("2 path 1");
id2 = camel_lock_helper_lock("2 path 2");
camel_lock_helper_unlock(id2);
camel_lock_helper_unlock(id1);
id1 = camel_lock_helper_lock("3 path 1");
id2 = camel_lock_helper_lock("3 path 2");
camel_lock_helper_unlock(id1);
}
#endif
