/* Lock files for editing.
- Copyright (C) 1985, 86, 87, 93, 94, 96, 98, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1993, 1994, 1996, 1998, 1999, 2000, 2001,
+ 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of GNU Emacs.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
+#include <config.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
-#include <config.h>
+#include <stdio.h>
-#ifdef VMS
-#include "vms-pwd.h"
-#else
+#ifdef HAVE_PWD_H
#include <pwd.h>
-#endif /* not VMS */
+#endif
#include <sys/file.h>
-#ifdef USG
+#ifdef HAVE_FCNTL_H
#include <fcntl.h>
+#endif
+#ifdef HAVE_STRING_H
#include <string.h>
-#endif /* USG */
+#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef __FreeBSD__
-#include <sys/time.h>
-#include <sys/types.h>
#include <sys/sysctl.h>
#endif /* __FreeBSD__ */
+#include <errno.h>
+#ifndef errno
+extern int errno;
+#endif
+
#include "lisp.h"
#include "buffer.h"
#include "charset.h"
#include "coding.h"
#include "systime.h"
-#include <time.h>
-#include <errno.h>
-#ifndef errno
-extern int errno;
-#endif
+/* The directory for writing temporary files. */
+
+Lisp_Object Vtemporary_file_directory;
#ifdef CLASH_DETECTION
#include <utmp.h>
+#if !defined (S_ISLNK) && defined (S_IFLNK)
+#define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
+#endif
+
+/* A file whose last-modified time is just after the most recent boot.
+ Define this to be NULL to disable checking for this file. */
+#ifndef BOOT_TIME_FILE
+#define BOOT_TIME_FILE "/var/run/random-seed"
+#endif
+
#ifndef WTMP_FILE
#define WTMP_FILE "/var/log/wtmp"
#endif
-
+
/* The strategy: to lock a file FN, create a symlink .#FN in FN's
directory, with link data `user@host.pid'. This avoids a single
mount (== failure) point for lock files.
When the host in the lock data is the current host, we can check if
the pid is valid with kill.
-
+
Otherwise, we could look at a separate file that maps hostnames to
reboot times to see if the remote pid can possibly be valid, since we
don't want Emacs to have to communicate via pipes or sockets or
files to be useful on old systems lacking symlinks, nowadays
virtually all such systems are probably single-user anyway, so it
didn't seem worth the complication.
-
+
Similarly, we don't worry about a possible 14-character limit on
file names, because those are all the same systems that don't have
symlinks.
-
+
This is compatible with the locking scheme used by Interleaf (which
has contributed this implementation for Emacs), and was designed by
Ethan Jacobson, Kimbo Mundy, and others.
-
+
--karl@cs.umb.edu/karl@hq.ileaf.com. */
\f
extern Lisp_Object Vshell_file_name;
+#ifdef BOOT_TIME
+static void get_boot_time_1 P_ ((char *, int));
+#endif
+
static time_t
get_boot_time ()
{
- struct utmp ut, *utp;
- int fd;
- EMACS_TIME time_before, after;
+#if defined (BOOT_TIME) && ! defined (NO_WTMP_FILE)
int counter;
+#endif
if (boot_time_initialized)
return boot_time;
boot_time_initialized = 1;
- EMACS_GET_TIME (time_before);
-
- /* Try calculating the last boot time
- from the uptime as obtained from /proc/uptime.
-
- This has a disadvantage in that if the system time has been
- changed (say to correct the clock),
- then current_time - uptime != wtmp_boot_time.
- However, the speedup from doing this can be so great
- that I think it is worth that problem occasionally. */
-
- while ((fd = open ("/proc/uptime", O_RDONLY)) >= 0)
- {
- char buf[100];
- int res;
- double upsecs;
- time_t uptime;
-
- read (fd, buf, sizeof buf);
- close (fd);
-
- res = sscanf (buf, "%lf", &upsecs);
-
- /* If the current time did not tick while we were getting the
- uptime, we have a valid result. */
- EMACS_GET_TIME (after);
- if (res == 1 && EMACS_SECS (after) == EMACS_SECS (time_before))
- {
- boot_time = EMACS_SECS (time_before) - (time_t) upsecs;
- return boot_time;
- }
-
- /* Otherwise, try again to read the uptime. */
- time_before = after;
- }
#if defined (CTL_KERN) && defined (KERN_BOOTTIME)
{
int mib[2];
}
#endif /* defined (CTL_KERN) && defined (KERN_BOOTTIME) */
+ if (BOOT_TIME_FILE)
+ {
+ struct stat st;
+ if (stat (BOOT_TIME_FILE, &st) == 0)
+ {
+ boot_time = st.st_mtime;
+ return boot_time;
+ }
+ }
+
#if defined (BOOT_TIME) && ! defined (NO_WTMP_FILE)
#ifndef CANNOT_DUMP
/* The utmp routines maintain static state.
if (! NILP (Ffile_exists_p (tempname)))
{
Lisp_Object args[6];
- tempname = Fmake_temp_name (build_string ("wtmp"));
+
+ /* The utmp functions on mescaline.gnu.org accept only
+ file names up to 8 characters long. Choose a 2
+ character long prefix, and call make_temp_file with
+ second arg non-zero, so that it will add not more
+ than 6 characters to the prefix. */
+ tempname = Fexpand_file_name (build_string ("wt"),
+ Vtemporary_file_directory);
+ tempname = make_temp_name (tempname, 1);
args[0] = Vshell_file_name;
args[1] = Qnil;
args[2] = Qnil;
args[3] = Qnil;
args[4] = build_string ("-c");
sprintf (cmd_string, "gunzip < %s.%d.gz > %s",
- WTMP_FILE, counter, XSTRING (tempname)->data);
+ WTMP_FILE, counter, SDATA (tempname));
args[5] = build_string (cmd_string);
Fcall_process (6, args);
filename = tempname;
if (! NILP (filename))
{
- get_boot_time_1 (XSTRING (filename)->data, 1);
+ get_boot_time_1 (SDATA (filename), 1);
if (delete_flag)
- unlink (XSTRING (filename)->data);
+ unlink (SDATA (filename));
}
}
Ignore all reboot records on or before BOOT_TIME.
Success is indicated by setting BOOT_TIME to a larger value. */
+void
get_boot_time_1 (filename, newest)
char *filename;
int newest;
{
/* On some versions of IRIX, opening a nonexistent file name
is likely to crash in the utmp routines. */
- desc = open (filename, O_RDONLY);
+ desc = emacs_open (filename, O_RDONLY, 0);
if (desc < 0)
return;
- close (desc);
+ emacs_close (desc);
utmpname (filename);
}
/* Write the name of the lock file for FN into LFNAME. Length will be
- that of FN plus two more for the leading `.#' plus one for the null. */
+ that of FN plus two more for the leading `.#' plus 1 for the
+ trailing period plus one for the digit after it plus one for the
+ null. */
#define MAKE_LOCK_NAME(lock, file) \
- (lock = (char *) alloca (STRING_BYTES (XSTRING (file)) + 2 + 1), \
+ (lock = (char *) alloca (SBYTES (file) + 2 + 1 + 1 + 1), \
fill_in_lock_file_name (lock, (file)))
static void
register Lisp_Object fn;
{
register char *p;
+ struct stat st;
+ int count = 0;
- strcpy (lockfile, XSTRING (fn)->data);
+ strcpy (lockfile, SDATA (fn));
/* Shift the nondirectory part of the file name (including the null)
right two characters. Here is one of the places where we'd have to
do something to support 14-character-max file names. */
for (p = lockfile + strlen (lockfile); p != lockfile && *p != '/'; p--)
p[2] = *p;
-
+
/* Insert the `.#'. */
p[1] = '.';
p[2] = '#';
+
+ p = p + strlen (p);
+
+ while (lstat (lockfile, &st) == 0 && !S_ISLNK (st.st_mode))
+ {
+ if (count > 9)
+ {
+ *p = '\0';
+ return;
+ }
+ sprintf (p, ".%d", count++);
+ }
}
/* Lock the lock file named LFNAME.
static int
lock_file_1 (lfname, force)
- char *lfname;
+ char *lfname;
int force;
{
register int err;
char *host_name;
char *lock_info_str;
+ /* Call this first because it can GC. */
+ boot_time = get_boot_time ();
+
if (STRINGP (Fuser_login_name (Qnil)))
- user_name = (char *)XSTRING (Fuser_login_name (Qnil))->data;
+ user_name = (char *)SDATA (Fuser_login_name (Qnil));
else
user_name = "";
if (STRINGP (Fsystem_name ()))
- host_name = (char *)XSTRING (Fsystem_name ())->data;
+ host_name = (char *)SDATA (Fsystem_name ());
else
host_name = "";
lock_info_str = (char *)alloca (strlen (user_name) + strlen (host_name)
- + LOCK_PID_MAX + 5);
+ + LOCK_PID_MAX + 30);
- boot_time = get_boot_time ();
if (boot_time)
sprintf (lock_info_str, "%s@%s.%lu:%lu", user_name, host_name,
(unsigned long) getpid (), (unsigned long) boot_time);
else
sprintf (lock_info_str, "%s@%s.%lu", user_name, host_name,
- (unsigned long) getpid ());
+ (unsigned long) getpid ());
err = symlink (lock_info_str, lfname);
if (errno == EEXIST && force)
#ifndef index
extern char *rindex (), *index ();
#endif
- int o, p, len, ret;
+ int len, ret;
int local_owner = 0;
char *at, *dot, *colon;
char *lfinfo = 0;
{
bufsize *= 2;
lfinfo = (char *) xrealloc (lfinfo, bufsize);
+ errno = 0;
len = readlink (lfname, lfinfo, bufsize);
+#ifdef ERANGE
+ /* HP-UX reports ERANGE if the buffer is too small. */
+ if (len == -1 && errno == ERANGE)
+ len = bufsize;
+#endif
}
while (len >= bufsize);
-
+
/* If nonexistent lock file, all is well; otherwise, got strange error. */
if (len == -1)
{
/* Link info exists, so `len' is its length. Null terminate. */
lfinfo[len] = 0;
-
+
/* Even if the caller doesn't want the owner info, we still have to
read it to determine return value, so allocate it. */
if (!owner)
owner = (lock_info_type *) alloca (sizeof (lock_info_type));
local_owner = 1;
}
-
+
/* Parse USER@HOST.PID:BOOT_TIME. If can't parse, return -1. */
/* The USER is everything before the first @. */
at = index (lfinfo, '@');
owner->user = (char *) xmalloc (len + 1);
strncpy (owner->user, lfinfo, len);
owner->user[len] = 0;
-
+
/* The PID is everything from the last `.' to the `:'. */
owner->pid = atoi (dot + 1);
colon = dot;
/* We're done looking at the link info. */
xfree (lfinfo);
-
+
/* On current host? */
if (STRINGP (Fsystem_name ())
- && strcmp (owner->host, XSTRING (Fsystem_name ())->data) == 0)
+ && strcmp (owner->host, SDATA (Fsystem_name ())) == 0)
{
if (owner->pid == getpid ())
ret = 2; /* We own it. */
here's where we'd do it. */
ret = 1;
}
-
+
/* Avoid garbage. */
if (local_owner || ret <= 0)
{
static int
lock_if_free (clasher, lfname)
lock_info_type *clasher;
- register char *lfname;
+ register char *lfname;
{
- if (lock_file_1 (lfname, 0) == 0)
+ while (lock_file_1 (lfname, 0) == 0)
{
int locker;
if (errno != EEXIST)
return -1;
-
+
locker = current_lock_owner (clasher, lfname);
if (locker == 2)
{
}
else if (locker == 1)
return 1; /* Someone else has it. */
+ else if (locker == -1)
+ return -1; /* current_lock_owner returned strange error. */
- return -1; /* Something's wrong. */
+ /* We deleted a stale lock; try again to lock the file. */
}
return 0;
}
register Lisp_Object attack, orig_fn, encoded_fn;
register char *lfname, *locker;
lock_info_type lock_info;
+ struct gcpro gcpro1;
+
+ /* Don't do locking while dumping Emacs.
+ Uncompressing wtmp files uses call-process, which does not work
+ in an uninitialized Emacs. */
+ if (! NILP (Vpurify_flag))
+ return;
orig_fn = fn;
+ GCPRO1 (fn);
fn = Fexpand_file_name (fn, Qnil);
encoded_fn = ENCODE_FILE (fn);
visited. */
{
register Lisp_Object subject_buf;
- struct gcpro gcpro1;
subject_buf = get_truename_buffer (orig_fn);
- GCPRO1 (fn);
if (!NILP (subject_buf)
&& NILP (Fverify_visited_file_modtime (subject_buf))
&& !NILP (Ffile_exists_p (fn)))
call1 (intern ("ask-user-about-supersession-threat"), fn);
- UNGCPRO;
}
+ UNGCPRO;
/* Try to lock the lock. */
if (lock_if_free (&lock_info, lfname) <= 0)
sprintf (locker, "%s@%s (pid %lu)", lock_info.user, lock_info.host,
lock_info.pid);
FREE_LOCK_INFO (lock_info);
-
+
attack = call2 (intern ("ask-user-about-lock"), fn, build_string (locker));
if (!NILP (attack))
/* User says take the lock */
register Lisp_Object tail;
register struct buffer *b;
- for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCDR (tail))
{
- b = XBUFFER (XCONS (XCONS (tail)->car)->cdr);
+ b = XBUFFER (XCDR (XCAR (tail)));
if (STRINGP (b->file_truename) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
{
- register char *lfname;
-
- MAKE_LOCK_NAME (lfname, b->file_truename);
-
- if (current_lock_owner (0, lfname) == 2)
- unlink (lfname);
+ unlock_file(b->file_truename);
}
}
}
\f
DEFUN ("lock-buffer", Flock_buffer, Slock_buffer,
- 0, 1, 0,
- "Lock FILE, if current buffer is modified.\n\
-FILE defaults to current buffer's visited file,\n\
-or else nothing is done if current buffer isn't visiting a file.")
- (file)
+ 0, 1, 0,
+ doc: /* Lock FILE, if current buffer is modified.
+FILE defaults to current buffer's visited file,
+or else nothing is done if current buffer isn't visiting a file. */)
+ (file)
Lisp_Object file;
{
if (NILP (file))
file = current_buffer->file_truename;
else
- CHECK_STRING (file, 0);
+ CHECK_STRING (file);
if (SAVE_MODIFF < MODIFF
&& !NILP (file))
lock_file (file);
- return Qnil;
+ return Qnil;
}
DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer,
- 0, 0, 0,
- "Unlock the file visited in the current buffer,\n\
-if it should normally be locked.")
- ()
+ 0, 0, 0,
+ doc: /* Unlock the file visited in the current buffer.
+If the buffer is not modified, this does nothing because the file
+should not be locked in that case. */)
+ ()
{
if (SAVE_MODIFF < MODIFF
&& STRINGP (current_buffer->file_truename))
unlock_file (buffer->file_truename);
}
-DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 0, 1, 0,
- "Return nil if the FILENAME is not locked,\n\
-t if it is locked by you, else a string of the name of the locker.")
- (filename)
- Lisp_Object filename;
+DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 1, 1, 0,
+ doc: /* Return a value indicating whether FILENAME is locked.
+The value is nil if the FILENAME is not locked,
+t if it is locked by you, else a string saying which user has locked it. */)
+ (filename)
+ Lisp_Object filename;
{
Lisp_Object ret;
register char *lfname;
void
syms_of_filelock ()
{
+ DEFVAR_LISP ("temporary-file-directory", &Vtemporary_file_directory,
+ doc: /* The directory for writing temporary files. */);
+ Vtemporary_file_directory = Qnil;
+
defsubr (&Sunlock_buffer);
defsubr (&Slock_buffer);
defsubr (&Sfile_locked_p);
}
#endif /* CLASH_DETECTION */
+
+/* arch-tag: e062676d-50b2-4be0-ab96-197c81b181a1
+ (do not change this comment) */