src/filelock.c

   1 /* Lock files for editing.
   2    Copyright (C) 1985, 1986, 1987, 1993, 1994, 1996, 1998, 1999, 2000, 2001,
   3                  2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4                  Free Software Foundation, Inc.
   5
   6 This file is part of GNU Emacs.
   7
   8 GNU Emacs is free software: you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation, either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 GNU Emacs is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21
  22 #include <config.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <signal.h>
  26 #include <stdio.h>
  27 #include <setjmp.h>
  28
  29 #ifdef HAVE_PWD_H
  30 #include <pwd.h>
  31 #endif
  32
  33 #include <sys/file.h>
  34 #ifdef HAVE_FCNTL_H
  35 #include <fcntl.h>
  36 #endif
  37 #ifdef HAVE_STRING_H
  38 #include <string.h>
  39 #endif
  40
  41 #ifdef HAVE_UNISTD_H
  42 #include <unistd.h>
  43 #endif
  44
  45 #ifdef __FreeBSD__
  46 #include <sys/sysctl.h>
  47 #endif /* __FreeBSD__ */
  48
  49 #include <errno.h>
  50 #ifndef errno
  51 extern int errno;
  52 #endif
  53
  54 #include "lisp.h"
  55 #include "buffer.h"
  56 #include "character.h"
  57 #include "coding.h"
  58 #include "systime.h"
  59
  60 /* The directory for writing temporary files.  */
  61
  62 Lisp_Object impl_Vtemporary_file_directory;
  63
  64 #ifdef CLASH_DETECTION
  65
  66 #ifdef HAVE_UTMP_H
  67 #include <utmp.h>
  68 #endif
  69
  70 #if !defined (S_ISLNK) && defined (S_IFLNK)
  71 #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
  72 #endif
  73
  74 /* A file whose last-modified time is just after the most recent boot.
  75    Define this to be NULL to disable checking for this file.  */
  76 #ifndef BOOT_TIME_FILE
  77 #define BOOT_TIME_FILE "/var/run/random-seed"
  78 #endif
  79
  80 #ifndef WTMP_FILE
  81 #define WTMP_FILE "/var/log/wtmp"
  82 #endif
  83
  84 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
  85    directory, with link data `user@host.pid'.  This avoids a single
  86    mount (== failure) point for lock files.
  87
  88    When the host in the lock data is the current host, we can check if
  89    the pid is valid with kill.
  90
  91    Otherwise, we could look at a separate file that maps hostnames to
  92    reboot times to see if the remote pid can possibly be valid, since we
  93    don't want Emacs to have to communicate via pipes or sockets or
  94    whatever to other processes, either locally or remotely; rms says
  95    that's too unreliable.  Hence the separate file, which could
  96    theoretically be updated by daemons running separately -- but this
  97    whole idea is unimplemented; in practice, at least in our
  98    environment, it seems such stale locks arise fairly infrequently, and
  99    Emacs' standard methods of dealing with clashes suffice.
 100
 101    We use symlinks instead of normal files because (1) they can be
 102    stored more efficiently on the filesystem, since the kernel knows
 103    they will be small, and (2) all the info about the lock can be read
 104    in a single system call (readlink).  Although we could use regular
 105    files to be useful on old systems lacking symlinks, nowadays
 106    virtually all such systems are probably single-user anyway, so it
 107    didn't seem worth the complication.
 108
 109    Similarly, we don't worry about a possible 14-character limit on
 110    file names, because those are all the same systems that don't have
 111    symlinks.
 112
 113    This is compatible with the locking scheme used by Interleaf (which
 114    has contributed this implementation for Emacs), and was designed by
 115    Ethan Jacobson, Kimbo Mundy, and others.
 116
 117    --karl@cs.umb.edu/karl@hq.ileaf.com.  */
 118
 119 \f
 120 /* Return the time of the last system boot.  */
 121
 122 static time_t boot_time;
 123 static int boot_time_initialized;
 124
 125 extern Lisp_Object impl_Vshell_file_name;
 126
 127 #ifdef BOOT_TIME
 128 static void get_boot_time_1 P_ ((char *, int));
 129 #endif
 130
 131 static time_t
 132 get_boot_time ()
 133 {
 134 #if defined (BOOT_TIME)
 135   int counter;
 136 #endif
 137
 138   if (boot_time_initialized)
 139     return boot_time;
 140   boot_time_initialized = 1;
 141
 142 #if defined (CTL_KERN) && defined (KERN_BOOTTIME)
 143   {
 144     int mib[2];
 145     size_t size;
 146     struct timeval boottime_val;
 147
 148     mib[0] = CTL_KERN;
 149     mib[1] = KERN_BOOTTIME;
 150     size = sizeof (boottime_val);
 151
 152     if (sysctl (mib, 2, &boottime_val, &size, NULL, 0) >= 0)
 153       {
 154         boot_time = boottime_val.tv_sec;
 155         return boot_time;
 156       }
 157   }
 158 #endif /* defined (CTL_KERN) && defined (KERN_BOOTTIME) */
 159
 160   if (BOOT_TIME_FILE)
 161     {
 162       struct stat st;
 163       if (stat (BOOT_TIME_FILE, &st) == 0)
 164         {
 165           boot_time = st.st_mtime;
 166           return boot_time;
 167         }
 168     }
 169
 170 #if defined (BOOT_TIME)
 171 #ifndef CANNOT_DUMP
 172   /* The utmp routines maintain static state.
 173      Don't touch that state unless we are initialized,
 174      since it might not survive dumping.  */
 175   if (! initialized)
 176     return boot_time;
 177 #endif /* not CANNOT_DUMP */
 178
 179   /* Try to get boot time from utmp before wtmp,
 180      since utmp is typically much smaller than wtmp.
 181      Passing a null pointer causes get_boot_time_1
 182      to inspect the default file, namely utmp.  */
 183   get_boot_time_1 ((char *) 0, 0);
 184   if (boot_time)
 185     return boot_time;
 186
 187   /* Try to get boot time from the current wtmp file.  */
 188   get_boot_time_1 (WTMP_FILE, 1);
 189
 190   /* If we did not find a boot time in wtmp, look at wtmp, and so on.  */
 191   for (counter = 0; counter < 20 && ! boot_time; counter++)
 192     {
 193       char cmd_string[100];
 194       Lisp_Object tempname, filename;
 195       int delete_flag = 0;
 196
 197       filename = Qnil;
 198
 199       sprintf (cmd_string, "%s.%d", WTMP_FILE, counter);
 200       tempname = build_string (cmd_string);
 201       if (! NILP (Ffile_exists_p (tempname)))
 202         filename = tempname;
 203       else
 204         {
 205           sprintf (cmd_string, "%s.%d.gz", WTMP_FILE, counter);
 206           tempname = build_string (cmd_string);
 207           if (! NILP (Ffile_exists_p (tempname)))
 208             {
 209               Lisp_Object args[6];
 210
 211               /* The utmp functions on mescaline.gnu.org accept only
 212                  file names up to 8 characters long.  Choose a 2
 213                  character long prefix, and call make_temp_file with
 214                  second arg non-zero, so that it will add not more
 215                  than 6 characters to the prefix.  */
 216               tempname = Fexpand_file_name (build_string ("wt"),
 217                                             Vtemporary_file_directory);
 218               tempname = make_temp_name (tempname, 1);
 219               args[0] = Vshell_file_name;
 220               args[1] = Qnil;
 221               args[2] = Qnil;
 222               args[3] = Qnil;
 223               args[4] = build_string ("-c");
 224               sprintf (cmd_string, "gunzip < %s.%d.gz > %s",
 225                        WTMP_FILE, counter, SDATA (tempname));
 226               args[5] = build_string (cmd_string);
 227               Fcall_process (6, args);
 228               filename = tempname;
 229               delete_flag = 1;
 230             }
 231         }
 232
 233       if (! NILP (filename))
 234         {
 235           get_boot_time_1 (SDATA (filename), 1);
 236           if (delete_flag)
 237             unlink (SDATA (filename));
 238         }
 239     }
 240
 241   return boot_time;
 242 #else
 243   return 0;
 244 #endif
 245 }
 246
 247 #ifdef BOOT_TIME
 248 /* Try to get the boot time from wtmp file FILENAME.
 249    This succeeds if that file contains a reboot record.
 250
 251    If FILENAME is zero, use the same file as before;
 252    if no FILENAME has ever been specified, this is the utmp file.
 253    Use the newest reboot record if NEWEST is nonzero,
 254    the first reboot record otherwise.
 255    Ignore all reboot records on or before BOOT_TIME.
 256    Success is indicated by setting BOOT_TIME to a larger value.  */
 257
 258 void
 259 get_boot_time_1 (filename, newest)
 260      char *filename;
 261      int newest;
 262 {
 263   struct utmp ut, *utp;
 264   int desc;
 265
 266   if (filename)
 267     {
 268       /* On some versions of IRIX, opening a nonexistent file name
 269          is likely to crash in the utmp routines.  */
 270       desc = emacs_open (filename, O_RDONLY, 0);
 271       if (desc < 0)
 272         return;
 273
 274       emacs_close (desc);
 275
 276       utmpname (filename);
 277     }
 278
 279   setutent ();
 280
 281   while (1)
 282     {
 283       /* Find the next reboot record.  */
 284       ut.ut_type = BOOT_TIME;
 285       utp = getutid (&ut);
 286       if (! utp)
 287         break;
 288       /* Compare reboot times and use the newest one.  */
 289       if (utp->ut_time > boot_time)
 290         {
 291           boot_time = utp->ut_time;
 292           if (! newest)
 293             break;
 294         }
 295       /* Advance on element in the file
 296          so that getutid won't repeat the same one.  */
 297       utp = getutent ();
 298       if (! utp)
 299         break;
 300     }
 301   endutent ();
 302 }
 303 #endif /* BOOT_TIME */
 304 \f
 305 /* Here is the structure that stores information about a lock.  */
 306
 307 typedef struct
 308 {
 309   char *user;
 310   char *host;
 311   unsigned long pid;
 312   time_t boot_time;
 313 } lock_info_type;
 314
 315 /* When we read the info back, we might need this much more,
 316    enough for decimal representation plus null.  */
 317 #define LOCK_PID_MAX (4 * sizeof (unsigned long))
 318
 319 /* Free the two dynamically-allocated pieces in PTR.  */
 320 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
 321
 322
 323 /* Write the name of the lock file for FN into LFNAME.  Length will be
 324    that of FN plus two more for the leading `.#' plus 1 for the
 325    trailing period plus one for the digit after it plus one for the
 326    null.  */
 327 #define MAKE_LOCK_NAME(lock, file) \
 328   (lock = (char *) alloca (SBYTES (file) + 2 + 1 + 1 + 1), \
 329    fill_in_lock_file_name (lock, (file)))
 330
 331 static void
 332 fill_in_lock_file_name (lockfile, fn)
 333      register char *lockfile;
 334      register Lisp_Object fn;
 335 {
 336   register char *p;
 337   struct stat st;
 338   int count = 0;
 339
 340   strcpy (lockfile, SDATA (fn));
 341
 342   /* Shift the nondirectory part of the file name (including the null)
 343      right two characters.  Here is one of the places where we'd have to
 344      do something to support 14-character-max file names.  */
 345   for (p = lockfile + strlen (lockfile); p != lockfile && *p != '/'; p--)
 346     p[2] = *p;
 347
 348   /* Insert the `.#'.  */
 349   p[1] = '.';
 350   p[2] = '#';
 351
 352   p = p + strlen (p);
 353
 354   while (lstat (lockfile, &st) == 0 && !S_ISLNK (st.st_mode))
 355     {
 356       if (count > 9)
 357         {
 358           *p = '\0';
 359           return;
 360         }
 361       sprintf (p, ".%d", count++);
 362     }
 363 }
 364
 365 /* Lock the lock file named LFNAME.
 366    If FORCE is nonzero, we do so even if it is already locked.
 367    Return 1 if successful, 0 if not.  */
 368
 369 static int
 370 lock_file_1 (lfname, force)
 371      char *lfname;
 372      int force;
 373 {
 374   register int err;
 375   time_t boot_time;
 376   char *user_name;
 377   char *host_name;
 378   char *lock_info_str;
 379
 380   /* Call this first because it can GC.  */
 381   boot_time = get_boot_time ();
 382
 383   if (STRINGP (Fuser_login_name (Qnil)))
 384     user_name = (char *)SDATA (Fuser_login_name (Qnil));
 385   else
 386     user_name = "";
 387   if (STRINGP (Fsystem_name ()))
 388     host_name = (char *)SDATA (Fsystem_name ());
 389   else
 390     host_name = "";
 391   lock_info_str = (char *)alloca (strlen (user_name) + strlen (host_name)
 392                                   + LOCK_PID_MAX + 30);
 393
 394   if (boot_time)
 395     sprintf (lock_info_str, "%s@%s.%lu:%lu", user_name, host_name,
 396              (unsigned long) getpid (), (unsigned long) boot_time);
 397   else
 398     sprintf (lock_info_str, "%s@%s.%lu", user_name, host_name,
 399              (unsigned long) getpid ());
 400
 401   err = symlink (lock_info_str, lfname);
 402   if (errno == EEXIST && force)
 403     {
 404       unlink (lfname);
 405       err = symlink (lock_info_str, lfname);
 406     }
 407
 408   return err == 0;
 409 }
 410
 411 /* Return 1 if times A and B are no more than one second apart.  */
 412
 413 int
 414 within_one_second (a, b)
 415      time_t a, b;
 416 {
 417   return (a - b >= -1 && a - b <= 1);
 418 }
 419 \f
 420 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
 421    1 if another process owns it (and set OWNER (if non-null) to info),
 422    2 if the current process owns it,
 423    or -1 if something is wrong with the locking mechanism.  */
 424
 425 static int
 426 current_lock_owner (owner, lfname)
 427      lock_info_type *owner;
 428      char *lfname;
 429 {
 430 #ifndef index
 431   extern char *rindex (), *index ();
 432 #endif
 433   int len, ret;
 434   int local_owner = 0;
 435   char *at, *dot, *colon;
 436   char *lfinfo = 0;
 437   int bufsize = 50;
 438   /* Read arbitrarily-long contents of symlink.  Similar code in
 439      file-symlink-p in fileio.c.  */
 440   do
 441     {
 442       bufsize *= 2;
 443       lfinfo = (char *) xrealloc (lfinfo, bufsize);
 444       errno = 0;
 445       len = readlink (lfname, lfinfo, bufsize);
 446 #ifdef ERANGE
 447       /* HP-UX reports ERANGE if the buffer is too small.  */
 448       if (len == -1 && errno == ERANGE)
 449         len = bufsize;
 450 #endif
 451     }
 452   while (len >= bufsize);
 453
 454   /* If nonexistent lock file, all is well; otherwise, got strange error. */
 455   if (len == -1)
 456     {
 457       xfree (lfinfo);
 458       return errno == ENOENT ? 0 : -1;
 459     }
 460
 461   /* Link info exists, so `len' is its length.  Null terminate.  */
 462   lfinfo[len] = 0;
 463
 464   /* Even if the caller doesn't want the owner info, we still have to
 465      read it to determine return value, so allocate it.  */
 466   if (!owner)
 467     {
 468       owner = (lock_info_type *) alloca (sizeof (lock_info_type));
 469       local_owner = 1;
 470     }
 471
 472   /* Parse USER@HOST.PID:BOOT_TIME.  If can't parse, return -1.  */
 473   /* The USER is everything before the last @.  */
 474   at = rindex (lfinfo, '@');
 475   dot = rindex (lfinfo, '.');
 476   if (!at || !dot)
 477     {
 478       xfree (lfinfo);
 479       return -1;
 480     }
 481   len = at - lfinfo;
 482   owner->user = (char *) xmalloc (len + 1);
 483   strncpy (owner->user, lfinfo, len);
 484   owner->user[len] = 0;
 485
 486   /* The PID is everything from the last `.' to the `:'.  */
 487   owner->pid = atoi (dot + 1);
 488   colon = dot;
 489   while (*colon && *colon != ':')
 490     colon++;
 491   /* After the `:', if there is one, comes the boot time.  */
 492   if (*colon == ':')
 493     owner->boot_time = atoi (colon + 1);
 494   else
 495     owner->boot_time = 0;
 496
 497   /* The host is everything in between.  */
 498   len = dot - at - 1;
 499   owner->host = (char *) xmalloc (len + 1);
 500   strncpy (owner->host, at + 1, len);
 501   owner->host[len] = 0;
 502
 503   /* We're done looking at the link info.  */
 504   xfree (lfinfo);
 505
 506   /* On current host?  */
 507   if (STRINGP (Fsystem_name ())
 508       && strcmp (owner->host, SDATA (Fsystem_name ())) == 0)
 509     {
 510       if (owner->pid == getpid ())
 511         ret = 2; /* We own it.  */
 512       else if (owner->pid > 0
 513                && (kill (owner->pid, 0) >= 0 || errno == EPERM)
 514                && (owner->boot_time == 0
 515                    || within_one_second (owner->boot_time, get_boot_time ())))
 516         ret = 1; /* An existing process on this machine owns it.  */
 517       /* The owner process is dead or has a strange pid (<=0), so try to
 518          zap the lockfile.  */
 519       else if (unlink (lfname) < 0)
 520         ret = -1;
 521       else
 522         ret = 0;
 523     }
 524   else
 525     { /* If we wanted to support the check for stale locks on remote machines,
 526          here's where we'd do it.  */
 527       ret = 1;
 528     }
 529
 530   /* Avoid garbage.  */
 531   if (local_owner || ret <= 0)
 532     {
 533       FREE_LOCK_INFO (*owner);
 534     }
 535   return ret;
 536 }
 537
 538 \f
 539 /* Lock the lock named LFNAME if possible.
 540    Return 0 in that case.
 541    Return positive if some other process owns the lock, and info about
 542      that process in CLASHER.
 543    Return -1 if cannot lock for any other reason.  */
 544
 545 static int
 546 lock_if_free (clasher, lfname)
 547      lock_info_type *clasher;
 548      register char *lfname;
 549 {
 550   while (lock_file_1 (lfname, 0) == 0)
 551     {
 552       int locker;
 553
 554       if (errno != EEXIST)
 555         return -1;
 556
 557       locker = current_lock_owner (clasher, lfname);
 558       if (locker == 2)
 559         {
 560           FREE_LOCK_INFO (*clasher);
 561           return 0;   /* We ourselves locked it.  */
 562         }
 563       else if (locker == 1)
 564         return 1;  /* Someone else has it.  */
 565       else if (locker == -1)
 566         return -1;   /* current_lock_owner returned strange error.  */
 567
 568       /* We deleted a stale lock; try again to lock the file.  */
 569     }
 570   return 0;
 571 }
 572
 573 /* lock_file locks file FN,
 574    meaning it serves notice on the world that you intend to edit that file.
 575    This should be done only when about to modify a file-visiting
 576    buffer previously unmodified.
 577    Do not (normally) call this for a buffer already modified,
 578    as either the file is already locked, or the user has already
 579    decided to go ahead without locking.
 580
 581    When this returns, either the lock is locked for us,
 582    or the user has said to go ahead without locking.
 583
 584    If the file is locked by someone else, this calls
 585    ask-user-about-lock (a Lisp function) with two arguments,
 586    the file name and info about the user who did the locking.
 587    This function can signal an error, or return t meaning
 588    take away the lock, or return nil meaning ignore the lock.  */
 589
 590 void
 591 lock_file (fn)
 592      Lisp_Object fn;
 593 {
 594   register Lisp_Object attack, orig_fn, encoded_fn;
 595   register char *lfname, *locker;
 596   lock_info_type lock_info;
 597   struct gcpro gcpro1;
 598
 599   /* Don't do locking while dumping Emacs.
 600      Uncompressing wtmp files uses call-process, which does not work
 601      in an uninitialized Emacs.  */
 602   if (! NILP (Vpurify_flag))
 603     return;
 604
 605   orig_fn = fn;
 606   GCPRO1 (fn);
 607   fn = Fexpand_file_name (fn, Qnil);
 608   encoded_fn = ENCODE_FILE (fn);
 609
 610   /* Create the name of the lock-file for file fn */
 611   MAKE_LOCK_NAME (lfname, encoded_fn);
 612
 613   /* See if this file is visited and has changed on disk since it was
 614      visited.  */
 615   {
 616     register Lisp_Object subject_buf;
 617
 618     subject_buf = get_truename_buffer (orig_fn);
 619
 620     if (!NILP (subject_buf)
 621         && NILP (Fverify_visited_file_modtime (subject_buf))
 622         && !NILP (Ffile_exists_p (fn)))
 623       call1 (intern ("ask-user-about-supersession-threat"), fn);
 624
 625   }
 626   UNGCPRO;
 627
 628   /* Try to lock the lock. */
 629   if (lock_if_free (&lock_info, lfname) <= 0)
 630     /* Return now if we have locked it, or if lock creation failed */
 631     return;
 632
 633   /* Else consider breaking the lock */
 634   locker = (char *) alloca (strlen (lock_info.user) + strlen (lock_info.host)
 635                             + LOCK_PID_MAX + 9);
 636   sprintf (locker, "%s@%s (pid %lu)", lock_info.user, lock_info.host,
 637            lock_info.pid);
 638   FREE_LOCK_INFO (lock_info);
 639
 640   attack = call2 (intern ("ask-user-about-lock"), fn, build_string (locker));
 641   if (!NILP (attack))
 642     /* User says take the lock */
 643     {
 644       lock_file_1 (lfname, 1);
 645       return;
 646     }
 647   /* User says ignore the lock */
 648 }
 649
 650 void
 651 unlock_file (fn)
 652      register Lisp_Object fn;
 653 {
 654   register char *lfname;
 655
 656   fn = Fexpand_file_name (fn, Qnil);
 657   fn = ENCODE_FILE (fn);
 658
 659   MAKE_LOCK_NAME (lfname, fn);
 660
 661   if (current_lock_owner (0, lfname) == 2)
 662     unlink (lfname);
 663 }
 664
 665 void
 666 unlock_all_files ()
 667 {
 668   register Lisp_Object tail;
 669   register struct buffer *b;
 670
 671   for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
 672     {
 673       b = XBUFFER (XCDR (XCAR (tail)));
 674       if (STRINGP (BUF_FILE_TRUENAME (b)) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
 675         {
 676           unlock_file(BUF_FILE_TRUENAME (b));
 677         }
 678     }
 679 }
 680 \f
 681 DEFUN ("lock-buffer", Flock_buffer, Slock_buffer,
 682        0, 1, 0,
 683        doc: /* Lock FILE, if current buffer is modified.
 684 FILE defaults to current buffer's visited file,
 685 or else nothing is done if current buffer isn't visiting a file.  */)
 686      (file)
 687      Lisp_Object file;
 688 {
 689   if (NILP (file))
 690     file = BUF_FILE_TRUENAME (current_buffer);
 691   else
 692     CHECK_STRING (file);
 693   if (SAVE_MODIFF < MODIFF
 694       && !NILP (file))
 695     lock_file (file);
 696   return Qnil;
 697 }
 698
 699 DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer,
 700        0, 0, 0,
 701        doc: /* Unlock the file visited in the current buffer.
 702 If the buffer is not modified, this does nothing because the file
 703 should not be locked in that case.  */)
 704      ()
 705 {
 706   if (SAVE_MODIFF < MODIFF
 707       && STRINGP (BUF_FILE_TRUENAME (current_buffer)))
 708     unlock_file (BUF_FILE_TRUENAME (current_buffer));
 709   return Qnil;
 710 }
 711
 712 /* Unlock the file visited in buffer BUFFER.  */
 713
 714 void
 715 unlock_buffer (buffer)
 716      struct buffer *buffer;
 717 {
 718   if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer)
 719       && STRINGP (BUF_FILE_TRUENAME (buffer)))
 720     unlock_file (BUF_FILE_TRUENAME (buffer));
 721 }
 722
 723 DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 1, 1, 0,
 724        doc: /* Return a value indicating whether FILENAME is locked.
 725 The value is nil if the FILENAME is not locked,
 726 t if it is locked by you, else a string saying which user has locked it.  */)
 727      (filename)
 728      Lisp_Object filename;
 729 {
 730   Lisp_Object ret;
 731   register char *lfname;
 732   int owner;
 733   lock_info_type locker;
 734
 735   filename = Fexpand_file_name (filename, Qnil);
 736
 737   MAKE_LOCK_NAME (lfname, filename);
 738
 739   owner = current_lock_owner (&locker, lfname);
 740   if (owner <= 0)
 741     ret = Qnil;
 742   else if (owner == 2)
 743     ret = Qt;
 744   else
 745     ret = build_string (locker.user);
 746
 747   if (owner > 0)
 748     FREE_LOCK_INFO (locker);
 749
 750   return ret;
 751 }
 752 \f
 753 /* Initialization functions.  */
 754
 755 void
 756 init_filelock ()
 757 {
 758   boot_time = 0;
 759   boot_time_initialized = 0;
 760 }
 761
 762 void
 763 syms_of_filelock ()
 764 {
 765   DEFVAR_LISP ("temporary-file-directory", &Vtemporary_file_directory,
 766                doc: /* The directory for writing temporary files.  */);
 767   Vtemporary_file_directory = Qnil;
 768
 769   defsubr (&Sunlock_buffer);
 770   defsubr (&Slock_buffer);
 771   defsubr (&Sfile_locked_p);
 772 }
 773
 774 #endif /* CLASH_DETECTION */
 775
 776 /* arch-tag: e062676d-50b2-4be0-ab96-197c81b181a1
 777    (do not change this comment) */