xemacs-beta: src/filelock.c comparison

comparison src/filelock.c @ 406:b8cc9ab3f761 r21-2-33

Import from CVS: tag r21-2-33

author	cvs
date	Mon, 13 Aug 2007 11:17:09 +0200
parents	2f8bb876ab1d
children	697ef44129c6

comparison

equal deleted inserted replaced

-:0e08f63c74d2
+:b8cc9ab3f761
 Lisp_Object Qask_user_about_supersession_threat;
 Lisp_Object Qask_user_about_lock;
 #ifdef CLASH_DETECTION
 /* 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
 whatever to other processes, either locally or remotely; rms says
 that's too unreliable.  Hence the separate file, which could
 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.  */
+/* Note that muleization is provided by using mule-encapsulated
+versions of the system calls we use like symlink(), unlink(), etc... */
 /* Here is the structure that stores information about a lock.  */
 typedef struct
 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
 /* 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.  */
 #define MAKE_LOCK_NAME(lock, file) \
-(lock = (char *) alloca (XSTRING_LENGTH(file) + 2 + 1), \
+(lock = (char *) alloca (XSTRING_LENGTH (file) + 2 + 1), \
-fill_in_lock_file_name (lock, (file)))
+fill_in_lock_file_name ((Bufbyte *) (lock), (file)))
 static void
-fill_in_lock_file_name (lockfile, fn)
+fill_in_lock_file_name (Bufbyte *lockfile, Lisp_Object fn)
-register char *lockfile;
+{
-register Lisp_Object fn;
+Bufbyte *file_name = XSTRING_DATA (fn);
-{
+Bufbyte *p;
-register char *p;
+size_t dirlen;
-strcpy (lockfile, XSTRING_DATA(fn));
+for (p = file_name + XSTRING_LENGTH (fn) - 1;
+p > file_name && !IS_ANY_SEP (p[-1]);
-/* Shift the nondirectory part of the file name (including the null)
+p--)
-right two characters.  Here is one of the places where we'd have to
+;
-do something to support 14-character-max file names.  */
+dirlen = p - file_name;
-for (p = lockfile + strlen (lockfile); p != lockfile && *p != '/'; p--)
-p[2] = *p;
+memcpy (lockfile, file_name, dirlen);
+p = lockfile + dirlen;
-/* Insert the `.#'.  */
+*(p++) = '.';
-p[1] = '.';
+*(p++) = '#';
-p[2] = '#';
+memcpy (p, file_name + dirlen, XSTRING_LENGTH (fn) - dirlen + 1);
 }
 /* Lock the lock file named LFNAME.
 If FORCE is nonzero, we do so even if it is already locked.
 Return 1 if successful, 0 if not.  */
 static int
-lock_file_1 (char *lfname,int force)
+lock_file_1 (char *lfname, int force)
 {
-register int err;
+int err;
-char *user_name;
+char *lock_info_str;
 char *host_name;
-char *lock_info_str;
+char *user_name = user_login_name (NULL);
-if (STRINGP (Fuser_login_name (Qnil)))
+if (user_name == NULL)
-user_name = (char *) XSTRING_DATA (Fuser_login_name (Qnil));
-else
 user_name = "";
-if (STRINGP (Fsystem_name ()))
-host_name = (char *) XSTRING_DATA (Fsystem_name ());
+if (STRINGP (Vsystem_name))
+host_name = (char *) XSTRING_DATA (Vsystem_name);
 else
 host_name = "";
 lock_info_str = (char *)alloca (strlen (user_name) + strlen (host_name)
 			  + LOCK_PID_MAX + 5);
 sprintf (lock_info_str, "%s@%s.%lu", user_name, host_name,
 (unsigned long) getpid ());
 err = symlink (lock_info_str, lfname);
-if (errno == EEXIST && force)
+if (err != 0 && errno == EEXIST && force)
 {
 unlink (lfname);
 err = symlink (lock_info_str, lfname);
 }
 or -1 if something is wrong with the locking mechanism.  */
 static int
 current_lock_owner (lock_info_type *owner, char *lfname)
 {
-int o, p, len, ret;
+int len, ret;
 int local_owner = 0;
 char *at, *dot;
 char *lfinfo = 0;
 int bufsize = 50;
 /* Read arbitrarily-long contents of symlink.  Similar code in
 bufsize *= 2;
 lfinfo = (char *) xrealloc (lfinfo, bufsize);
 len = readlink (lfname, lfinfo, bufsize);
 }
 while (len >= bufsize);
 /* If nonexistent lock file, all is well; otherwise, got strange error. */
 if (len == -1)
 {
 xfree (lfinfo);
 return errno == ENOENT ? 0 : -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.  If can't parse, return -1.  */
 /* The USER is everything before the first @.  */
 at = strchr (lfinfo, '@');
 dot = strrchr (lfinfo, '.');
 if (!at || !dot) {
 }
 len = at - lfinfo;
 owner->user = (char *) xmalloc (len + 1);
 strncpy (owner->user, lfinfo, len);
 owner->user[len] = 0;
 /* The PID is everything after the last `.'.  */
 owner->pid = atoi (dot + 1);
 /* The host is everything in between.  */
 len = dot - at - 1;
 strncpy (owner->host, at + 1, len);
 owner->host[len] = 0;
 /* We're done looking at the link info.  */
 xfree (lfinfo);
 /* On current host?  */
 if (STRINGP (Fsystem_name ())
-&& strcmp (owner->host, XSTRING_DATA(Fsystem_name ())) == 0)
+&& strcmp (owner->host, (char *) XSTRING_DATA (Fsystem_name ())) == 0)
 {
 if (owner->pid == getpid ())
 ret = 2; /* We own it.  */
 else if (owner->pid > 0
 && (kill (owner->pid, 0) >= 0 || errno == EPERM))
 else
 { /* If we wanted to support the check for stale locks on remote machines,
 here's where we'd do it.  */
 ret = 1;
 }
 /* Avoid garbage.  */
 if (local_owner || ret <= 0)
 {
 FREE_LOCK_INFO (*owner);
 }
 {
 int locker;
 if (errno != EEXIST)
 	return -1;
 locker = current_lock_owner (clasher, lfname);
 if (locker == 2)
 {
 FREE_LOCK_INFO (*clasher);
 return 0;   /* We ourselves locked it.  */
 {
 /* This function can GC. */
 /* dmoore - and can destroy current_buffer and all sorts of other
 mean nasty things with pointy teeth.  If you call this make sure
 you protect things right. */
 /* Somebody updated the code in this function and removed the previous
 comment.  -slb */
 register Lisp_Object attack, orig_fn;
 register char *lfname, *locker;
 lock_info_type lock_info;
 subject_buf = get_truename_buffer (orig_fn);
 if (!NILP (subject_buf)
 	&& NILP (Fverify_visited_file_modtime (subject_buf))
 	&& !NILP (Ffile_exists_p (fn)))
 call1_in_buffer (XBUFFER(subject_buf),
-			Qask_user_about_supersession_threat, fn);
+		       Qask_user_about_supersession_threat, fn);
 }
 /* Try to lock the lock. */
 if (lock_if_free (&lock_info, lfname) <= 0)
 /* Return now if we have locked it, or if lock creation failed */
 locker = (char *) alloca (strlen (lock_info.user) + strlen (lock_info.host)
 			    + LOCK_PID_MAX + 9);
 sprintf (locker, "%s@%s (pid %lu)", lock_info.user, lock_info.host,
 lock_info.pid);
 FREE_LOCK_INFO (lock_info);
 attack = call2_in_buffer (BUFFERP (subject_buf) ? XBUFFER (subject_buf) :
 			    current_buffer, Qask_user_about_lock , fn,
 			    build_string (locker));
 if (!NILP (attack))
 /* User says take the lock */
 void
 unlock_file (Lisp_Object fn)
 {
 register char *lfname;
+struct gcpro gcpro1;
+GCPRO1 (fn);
 fn = Fexpand_file_name (fn, Qnil);
 MAKE_LOCK_NAME (lfname, fn);
 if (current_lock_owner (0, lfname) == 2)
 unlink (lfname);
+UNGCPRO;
 }
 void
 unlock_all_files (void)
 {
 register Lisp_Object tail;
-register struct buffer *b;
 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
 {
-b = XBUFFER (XCDR (XCAR (tail)));
+struct buffer *b = XBUFFER (XCDR (XCAR (tail)));
 if (STRINGP (b->file_truename) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
 	unlock_file (b->file_truename);
 }
 }
 DEFUN ("lock-buffer", Flock_buffer,   0, 1, 0, /*
-Lock FILE, if current buffer is modified.\n\
+Lock FILE, if current buffer is modified.
-FILE defaults to current buffer's visited file,\n\
+FILE defaults to current buffer's visited file,
 or else nothing is done if current buffer isn't visiting a file.
 */
 (file))
 {
 if (NILP (file))
 file = current_buffer->file_truename;
 CHECK_STRING (file);
 if (BUF_SAVE_MODIFF (current_buffer) < BUF_MODIFF (current_buffer)
 && STRINGP (buffer->file_truename))
 unlock_file (buffer->file_truename);
 }
 DEFUN ("file-locked-p", Ffile_locked_p, 0, 1, 0, /*
-Return nil if the FILENAME is not locked,\n\
+Return nil if the FILENAME is not locked,
 t if it is locked by you, else a string of the name of the locker.
 */
 (filename))
 {
 Lisp_Object ret;
 register char *lfname;
 int owner;
 lock_info_type locker;
+struct gcpro gcpro1;
+GCPRO1 (filename);
 filename = Fexpand_file_name (filename, Qnil);
 MAKE_LOCK_NAME (lfname, filename);
 ret = build_string (locker.user);
 if (owner > 0)
 FREE_LOCK_INFO (locker);
+UNGCPRO;
 return ret;
 }
 /* Initialization functions.  */

Mercurial > hg > xemacs-beta

comparison src/filelock.c @ 406:b8cc9ab3f761 r21-2-33