--- sylpheed/src/inc.c.alt-mboxlock	2006-03-09 09:37:55 +0300
+++ sylpheed/src/inc.c	2006-05-27 23:10:03 +0400
@@ -1257,7 +1257,7 @@ static gint inc_spool(void)
 static gint get_spool(FolderItem *dest, const gchar *mbox)
 {
 	gint msgs, size;
-	gint lockfd;
+	FILE *mbox_fp;
 	gchar tmp_mbox[MAXPATHLEN + 1];
 	GHashTable *folder_table = NULL;
 
@@ -1270,14 +1270,14 @@ static gint get_spool(FolderItem *dest, 
 	} else if (size < 0)
 		return -1;
 
-	if ((lockfd = lock_mbox(mbox, LOCK_FLOCK)) < 0)
+	if ((mbox_fp = open_and_lock_mbox(mbox, LOCK_FLOCK)) == NULL)
 		return -1;
 
 	g_snprintf(tmp_mbox, sizeof(tmp_mbox), "%s%ctmpmbox.%p",
 		   get_tmp_dir(), G_DIR_SEPARATOR, mbox);
 
-	if (copy_mbox(mbox, tmp_mbox) < 0) {
-		unlock_mbox(mbox, lockfd, LOCK_FLOCK);
+	if (copy_mbox(mbox, mbox_fp, tmp_mbox) < 0) {
+		unlock_and_close_mbox(mbox, mbox_fp, LOCK_FLOCK);
 		return -1;
 	}
 
@@ -1289,8 +1289,8 @@ static gint get_spool(FolderItem *dest, 
 	msgs = proc_mbox(dest, tmp_mbox, folder_table);
 
 	g_unlink(tmp_mbox);
-	if (msgs >= 0) empty_mbox(mbox);
-	unlock_mbox(mbox, lockfd, LOCK_FLOCK);
+	if (msgs >= 0) empty_mbox(mbox, mbox_fp);
+	unlock_and_close_mbox(mbox, mbox_fp, LOCK_FLOCK);
 
 	if (folder_table) {
 		if (!prefs_common.scan_all_after_inc) {
--- sylpheed/configure.in.alt-mboxlock	2006-05-26 13:19:30 +0400
+++ sylpheed/configure.in	2006-05-27 23:10:58 +0400
@@ -343,6 +343,14 @@ if test $ac_cv_dirent_d_type = yes; then
 fi
 
 
+dnl Select spool locking type
+AC_ARG_ENABLE(flock,
+	[  --enable-flock          Lock spool mailbox with flock],
+	[ac_cv_enable_flock=$enableval], [ac_cv_enable_flock=maybe])
+AC_ARG_ENABLE(fcntl,
+	[  --enable-fcntl          Lock spool mailbox with fcntl],
+	[ac_cv_enable_fcntl=$enableval], [ac_cv_enable_fcntl=maybe])
+
 dnl Checks for header files.
 AC_HEADER_DIRENT
 AC_HEADER_STDC
@@ -370,7 +378,40 @@ dnl Checks for library functions.
 AC_FUNC_ALLOCA
 AC_CHECK_FUNCS(gethostname mkdir mktime socket strstr strchr \
 	       uname flock lockf inet_aton inet_addr \
-	       fchmod truncate getuid regcomp mlock)
+	       fchmod truncate ftruncate getuid regcomp mlock)
+
+dnl Finish locking decision
+
+dnl Turn off unavailable methods
+if test x"$ac_cv_have_flock" = xno; then
+	ac_cv_enable_flock=no
+fi
+if test x"$ac_cv_have_fcntl" = xno; then
+	ac_cv_enable_fcntl=no
+fi
+
+dnl If no --enable-... is given, prefer flock to fcntl
+dnl (compatible with the previous behavior)
+if test x"$ac_cv_enable_flock" = xmaybe; then
+	ac_cv_enable_flock=yes
+fi
+if test x"$ac_cv_enable_fcntl" = xmaybe; then
+	if test x"$ac_cv_enable_flock" = xno; then
+		ac_cv_enable_fcntl=yes
+	else
+		ac_cv_enable_fcntl=no
+	fi
+fi
+
+dnl Define the macros
+if test x"$ac_cv_enable_flock" = xyes; then
+	AC_DEFINE(LOCK_WITH_FLOCK, 1,
+		 [Define to use the flock function for mailbox locking])
+fi
+if test x"$ac_cv_enable_fcntl" = xyes; then
+	AC_DEFINE(LOCK_WITH_FCNTL, 1,
+		 [Define to use the fcntl function for mailbox locking])
+fi
 
 AC_OUTPUT([
 Makefile
@@ -403,6 +444,8 @@ echo "OpenSSL       : $ac_cv_enable_ssl"
 echo "iconv         : $am_cv_func_iconv"
 echo "compface      : $ac_cv_enable_compface"
 echo "IPv6          : $ac_cv_enable_ipv6"
+echo "flock locking : $ac_cv_enable_flock"
+echo "fcntl locking : $ac_cv_enable_fcntl"
 echo "GtkSpell      : $ac_cv_enable_gtkspell"
 echo ""
 echo "The binary will be installed in $prefix/bin"
--- sylpheed/libsylph/mbox.h.alt-mboxlock	2005-09-13 12:18:44 +0400
+++ sylpheed/libsylph/mbox.h	2006-05-27 22:56:39 +0400
@@ -21,6 +21,7 @@
 #define __MBOX_H__
 
 #include <glib.h>
+#include <stdio.h>
 
 #include "folder.h"
 
@@ -29,19 +30,21 @@ typedef enum {
 	LOCK_FLOCK
 } LockType;
 
-gint proc_mbox		(FolderItem	*dest,
-			 const gchar	*mbox,
-			 GHashTable	*folder_table);
-gint lock_mbox		(const gchar	*base,
-			 LockType	 type);
-gint unlock_mbox	(const gchar	*base,
-			 gint		 fd,
-			 LockType	 type);
-gint copy_mbox		(const gchar	*src,
-			 const gchar	*dest);
-void empty_mbox		(const gchar	*mbox);
+gint   proc_mbox		(FolderItem	*dest,
+				 const gchar	*mbox,
+				 GHashTable	*folder_table);
+FILE * open_and_lock_mbox	(const gchar	*base,
+				 LockType	 type);
+gint   unlock_and_close_mbox	(const gchar	*base,
+				 FILE		*fp,
+				 LockType	 type);
+gint   copy_mbox		(const gchar	*src,
+				 FILE		*src_fp,
+				 const gchar	*dest);
+void   empty_mbox		(const gchar	*mbox,
+				 FILE		*mbox_fp);
 
-gint export_to_mbox	(FolderItem	*src,
-			 const gchar	*mbox);
+gint   export_to_mbox		(FolderItem	*src,
+				 const gchar	*mbox);
 
 #endif /* __MBOX_H__ */
--- sylpheed/libsylph/utils.h.alt-mboxlock	2006-03-27 12:19:53 +0400
+++ sylpheed/libsylph/utils.h	2006-05-27 23:03:14 +0400
@@ -407,6 +407,10 @@ gint remove_expired_files	(const gchar	*
 gint remove_dir_recursive	(const gchar	*dir);
 gint rename_force		(const gchar	*oldpath,
 				 const gchar	*newpath);
+gint copy_open_file		(const gchar	*src,
+				 FILE 		*src_fp,
+				 const gchar	*dest,
+				 gboolean	 keep_backup);
 gint copy_file			(const gchar	*src,
 				 const gchar	*dest,
 				 gboolean	 keep_backup);
--- sylpheed/libsylph/mbox.c.alt-mboxlock	2005-11-14 13:00:00 +0300
+++ sylpheed/libsylph/mbox.c	2006-05-27 23:29:15 +0400
@@ -252,142 +252,206 @@ gint proc_mbox(FolderItem *dest, const g
 	return msgs;
 }
 
-gint lock_mbox(const gchar *base, LockType type)
+static gint lock_dotlock(const gchar *base)
 {
-#ifdef G_OS_UNIX
-	gint retval = 0;
+#ifdef LOCK_WITH_DOTLOCK
+	gchar *lockfile, *locklink;
+	gint retry = 0;
+	FILE *lockfp;
+
+	lockfile = g_strdup_printf("%s.%d", base, getpid());
+	if ((lockfp = g_fopen(lockfile, "wb")) == NULL) {
+		FILE_OP_ERROR(lockfile, "fopen");
+		g_warning(_("can't create lock file %s\n"), lockfile);
+		g_warning(_("use 'flock' instead of 'file' if possible.\n"));
+		g_free(lockfile);
+		return NULL;
+	}
 
-	if (type == LOCK_FILE) {
-		gchar *lockfile, *locklink;
-		gint retry = 0;
-		FILE *lockfp;
-
-		lockfile = g_strdup_printf("%s.%d", base, getpid());
-		if ((lockfp = g_fopen(lockfile, "wb")) == NULL) {
-			FILE_OP_ERROR(lockfile, "fopen");
-			g_warning(_("can't create lock file %s\n"), lockfile);
-			g_warning(_("use 'flock' instead of 'file' if possible.\n"));
+	fprintf(lockfp, "%d\n", getpid());
+	fclose(lockfp);
+
+	locklink = g_strconcat(base, ".lock", NULL);
+	while (link(lockfile, locklink) < 0) {
+		FILE_OP_ERROR(lockfile, "link");
+		if (retry >= 5) {
+			g_warning(_("can't create %s\n"), lockfile);
+			g_unlink(lockfile);
 			g_free(lockfile);
 			return -1;
 		}
+		if (retry == 0)
+			g_warning(_("mailbox is owned by another"
+				    " process, waiting...\n"));
+		retry++;
+		sleep(5);
+	}
+	g_unlink(lockfile);
+	g_free(lockfile);
+#endif /* LOCK_WITH_DOTLOCK */
 
-		fprintf(lockfp, "%d\n", getpid());
-		fclose(lockfp);
+	return 0;
+}
 
-		locklink = g_strconcat(base, ".lock", NULL);
-		while (link(lockfile, locklink) < 0) {
-			FILE_OP_ERROR(lockfile, "link");
-			if (retry >= 5) {
-				g_warning(_("can't create %s\n"), lockfile);
-				g_unlink(lockfile);
-				g_free(lockfile);
-				return -1;
-			}
-			if (retry == 0)
-				g_warning(_("mailbox is owned by another"
-					    " process, waiting...\n"));
-			retry++;
-			sleep(5);
-		}
-		g_unlink(lockfile);
+static gint unlock_dotlock(const gchar *base)
+{
+#ifdef LOCK_WITH_DOTLOCK
+	gchar *lockfile;
+
+	lockfile = g_strconcat(base, ".lock", NULL);
+	if (g_unlink(lockfile) < 0) {
+		FILE_OP_ERROR(lockfile, "unlink");
 		g_free(lockfile);
-	} else if (type == LOCK_FLOCK) {
-		gint lockfd;
+		return -1;
+	}
+	g_free(lockfile);
+#endif /* LOCK_WITH_DOTLOCK */
 
-#if HAVE_FLOCK
-		if ((lockfd = open(base, O_RDONLY)) < 0) {
-#else
-		if ((lockfd = open(base, O_RDWR)) < 0) {
-#endif
-			FILE_OP_ERROR(base, "open");
+	return 0;
+}
+
+static gint lock_fcntl(const gchar *base, gint fd)
+{
+#ifdef LOCK_WITH_FCNTL
+	struct flock lck;
+
+	memset(&lck, 0, sizeof (struct flock));
+	lck.l_type = F_WRLCK;
+	lck.l_whence = SEEK_SET;
+
+	if (fcntl(fd, F_SETLK, &lck) == -1) {
+		if (errno != EAGAIN && errno != EACCES) {
+			FILE_OP_ERROR(base, "fcntl lock");
 			return -1;
 		}
-#if HAVE_FLOCK
-		if (flock(lockfd, LOCK_EX|LOCK_NB) < 0) {
-			perror("flock");
-#else
-#if HAVE_LOCKF
-		if (lockf(lockfd, F_TLOCK, 0) < 0) {
-			perror("lockf");
-#else
-		{
-#endif
-#endif /* HAVE_FLOCK */
-			g_warning(_("can't lock %s\n"), base);
-			if (close(lockfd) < 0)
-				perror("close");
+
+		g_warning(_("can't lock %s with fcntl\n"), base);
+		return -1;
+	}
+#endif /* LOCK_WITH_FCNTL */
+
+	return 0;
+}
+
+static gint unlock_fcntl(const gchar *base, gint fd)
+{
+#ifdef LOCK_WITH_FCNTL
+      	struct flock lck;
+
+	memset(&lck, 0, sizeof (struct flock));
+	lck.l_type = F_UNLCK;
+	lck.l_whence = SEEK_SET;
+	if (fcntl(fd, F_SETLK, &lck) == -1) {
+		FILE_OP_ERROR(base, "fcntl unlock");
+		return -1;
+	}
+#endif /* LOCK_WITH_FCNTL */
+
+	return 0;
+}
+
+static gint lock_flock(const gchar *base, gint fd)
+{
+#ifdef LOCK_WITH_FLOCK
+	if (flock(fd, LOCK_EX | LOCK_NB) == -1)
+	{
+		if (errno != EWOULDBLOCK) {
+			FILE_OP_ERROR(base, "flock lock");
 			return -1;
 		}
-		retval = lockfd;
-	} else {
-		g_warning(_("invalid lock type\n"));
+
+		g_warning(_("can't lock %s with flock\n"), base);
 		return -1;
 	}
+#endif /* LOCK_WITH_FLOCK */
 
-	return retval;
-#else
-	return -1;
-#endif /* G_OS_UNIX */
+	return 0;
 }
 
-gint unlock_mbox(const gchar *base, gint fd, LockType type)
+static gint unlock_flock(const gchar *base, gint fd)
 {
-	if (type == LOCK_FILE) {
-		gchar *lockfile;
+#ifdef LOCK_WITH_FLOCK
+	if (flock(fd, LOCK_UN) == -1) {
+		FILE_OP_ERROR(base, "flock unlock");
+		return -1;
+	}
+#endif /* LOCK_WITH_FLOCK */
 
-		lockfile = g_strconcat(base, ".lock", NULL);
-		if (g_unlink(lockfile) < 0) {
-			FILE_OP_ERROR(lockfile, "unlink");
-			g_free(lockfile);
-			return -1;
+	return 0;
+}
+
+FILE *open_and_lock_mbox(const gchar *base, LockType type)
+{
+#ifdef G_OS_UNIX
+	FILE *mbox_fp;
+	gint fd;
+
+	mbox_fp = g_fopen(base, "rb+");
+	if (mbox_fp == NULL) {
+		FILE_OP_ERROR(base, "fopen");
+		return NULL;
+	}
+	fd = fileno(mbox_fp);
+
+	if (lock_fcntl(base, fd) == -1) {
+		fclose(mbox_fp);
+		return NULL;
+	}
+
+	if (lock_flock(base, fd) == -1) {
+		unlock_fcntl(base, fd);
+		fclose(mbox_fp);
+		return NULL;
+	}
+
+	if (type == LOCK_FILE) {
+		if (lock_dotlock(base) == -1) {
+			unlock_flock(base, fd);
+			unlock_fcntl(base, fd);
+			fclose(mbox_fp);
+			return NULL;
 		}
-		g_free(lockfile);
+	}
 
-		return 0;
-	} else if (type == LOCK_FLOCK) {
-#if HAVE_FLOCK
-		if (flock(fd, LOCK_UN) < 0) {
-			perror("flock");
-#else
-#if HAVE_LOCKF
-		if (lockf(fd, F_ULOCK, 0) < 0) {
-			perror("lockf");
+	return mbox_fp;
 #else
-		{
-#endif
-#endif /* HAVE_FLOCK */
-			g_warning(_("can't unlock %s\n"), base);
-			if (close(fd) < 0)
-				perror("close");
-			return -1;
-		}
+	return NULL;
+#endif  /* G_OS_UNIX */
+}
 
-		if (close(fd) < 0) {
-			perror("close");
-			return -1;
-		}
+gint unlock_and_close_mbox(const gchar *base, FILE *mbox_fp, LockType type)
+{
+	gint fd = fileno(mbox_fp);
 
-		return 0;
+	unlock_fcntl(base, fd);
+	unlock_flock(base, fd);
+	if (type == LOCK_FILE)
+		unlock_dotlock(base);
+
+	if (fclose(mbox_fp) == EOF) {
+		FILE_OP_ERROR(base, "fclose");
+		return -1;
 	}
 
-	g_warning(_("invalid lock type\n"));
-	return -1;
+	return 0;
 }
 
-gint copy_mbox(const gchar *src, const gchar *dest)
+gint copy_mbox(const gchar *src, FILE *src_fp, const gchar *dest)
 {
-	return copy_file(src, dest, TRUE);
+	return copy_open_file(src, src_fp, dest, TRUE);
 }
 
-void empty_mbox(const gchar *mbox)
+void empty_mbox(const gchar *mbox, FILE *mbox_fp)
 {
-#if HAVE_TRUNCATE
-	if (truncate(mbox, 0) < 0) {
+#if HAVE_FTRUNCATE
+	int fd = fileno(mbox_fp);
+
+	if (ftruncate(fd, 0) < 0) {
 #endif
 		FILE *fp;
 
-#if HAVE_TRUNCATE
-		FILE_OP_ERROR(mbox, "truncate");
+#if HAVE_FTRUNCATE
+		FILE_OP_ERROR(mbox, "ftruncate");
 #endif
 		if ((fp = g_fopen(mbox, "wb")) == NULL) {
 			FILE_OP_ERROR(mbox, "fopen");
@@ -395,7 +459,7 @@ void empty_mbox(const gchar *mbox)
 			return;
 		}
 		fclose(fp);
-#if HAVE_TRUNCATE
+#if HAVE_FTRUNCATE
 	}
 #endif
 }
--- sylpheed/libsylph/utils.c.alt-mboxlock	2006-03-27 12:19:53 +0400
+++ sylpheed/libsylph/utils.c	2006-05-27 23:08:03 +0400
@@ -2423,23 +2423,19 @@ gint rename_force(const gchar *oldpath, 
 	return g_rename(oldpath, newpath);
 }
 
-gint copy_file(const gchar *src, const gchar *dest, gboolean keep_backup)
+gint copy_open_file(const gchar *src, FILE *src_fp, const gchar *dest,
+		    gboolean keep_backup)
 {
-	FILE *src_fp, *dest_fp;
+	FILE *dest_fp;
 	gint n_read;
 	gchar buf[BUFSIZ];
 	gchar *dest_bak = NULL;
 	gboolean err = FALSE;
 
-	if ((src_fp = g_fopen(src, "rb")) == NULL) {
-		FILE_OP_ERROR(src, "fopen");
-		return -1;
-	}
 	if (is_file_exist(dest)) {
 		dest_bak = g_strconcat(dest, ".bak", NULL);
 		if (rename_force(dest, dest_bak) < 0) {
 			FILE_OP_ERROR(dest, "rename");
-			fclose(src_fp);
 			g_free(dest_bak);
 			return -1;
 		}
@@ -2447,7 +2443,6 @@ gint copy_file(const gchar *src, const g
 
 	if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
 		FILE_OP_ERROR(dest, "fopen");
-		fclose(src_fp);
 		if (dest_bak) {
 			if (rename_force(dest_bak, dest) < 0)
 				FILE_OP_ERROR(dest_bak, "rename");
@@ -2467,7 +2462,6 @@ gint copy_file(const gchar *src, const g
 		if (fwrite(buf, n_read, 1, dest_fp) < 1) {
 			g_warning(_("writing to %s failed.\n"), dest);
 			fclose(dest_fp);
-			fclose(src_fp);
 			g_unlink(dest);
 			if (dest_bak) {
 				if (rename_force(dest_bak, dest) < 0)
@@ -2482,7 +2476,6 @@ gint copy_file(const gchar *src, const g
 		FILE_OP_ERROR(src, "fread");
 		err = TRUE;
 	}
-	fclose(src_fp);
 	if (fclose(dest_fp) == EOF) {
 		FILE_OP_ERROR(dest, "fclose");
 		err = TRUE;
@@ -2506,6 +2499,20 @@ gint copy_file(const gchar *src, const g
 	return 0;
 }
 
+gint copy_file(const gchar *src, const gchar *dest, gboolean keep_backup)
+{
+	FILE *src_fp;
+	gint result;
+
+	if ((src_fp = g_fopen(src, "rb")) == NULL) {
+		FILE_OP_ERROR(src, "fopen");
+		return -1;
+	}
+	result = copy_open_file(src, src_fp, dest, keep_backup);
+	fclose(src_fp);
+	return result;
+}
+
 gint copy_dir(const gchar *src, const gchar *dest)
 {
 	GDir *dir;