src/filelock.c

   1 /* Copyright (C) 1985, 86, 87, 93, 94, 96 Free Software Foundation, Inc.
   2
   3 This file is part of GNU Emacs.
   4
   5 GNU Emacs is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 GNU Emacs is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU Emacs; see the file COPYING.  If not, write to
  17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18 Boston, MA 02111-1307, USA.  */
  19
  20
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <signal.h>
  24 #include <config.h>
  25
  26 #ifdef VMS
  27 #include "vms-pwd.h"
  28 #else
  29 #include <pwd.h>
  30 #endif /* not VMS */
  31
  32 #include <sys/file.h>
  33 #ifdef USG
  34 #include <fcntl.h>
  35 #include <string.h>
  36 #endif /* USG */
  37
  38 #ifdef HAVE_UNISTD_H
  39 #include <unistd.h>
  40 #endif
  41
  42 #include "lisp.h"
  43 #include "buffer.h"
  44 #include "charset.h"
  45 #include "coding.h"
  46
  47 #include <time.h>
  48 #include <errno.h>
  49 #ifndef errno
  50 extern int errno;
  51 #endif
  52
  53 #ifdef CLASH_DETECTION
  54
  55 #include <utmp.h>
  56
  57 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
  58    directory, with link data `user@host.pid'.  This avoids a single
  59    mount (== failure) point for lock files.
  60
  61    When the host in the lock data is the current host, we can check if
  62    the pid is valid with kill.
  63
  64    Otherwise, we could look at a separate file that maps hostnames to
  65    reboot times to see if the remote pid can possibly be valid, since we
  66    don't want Emacs to have to communicate via pipes or sockets or
  67    whatever to other processes, either locally or remotely; rms says
  68    that's too unreliable.  Hence the separate file, which could
  69    theoretically be updated by daemons running separately -- but this
  70    whole idea is unimplemented; in practice, at least in our
  71    environment, it seems such stale locks arise fairly infrequently, and
  72    Emacs' standard methods of dealing with clashes suffice.
  73
  74    We use symlinks instead of normal files because (1) they can be
  75    stored more efficiently on the filesystem, since the kernel knows
  76    they will be small, and (2) all the info about the lock can be read
  77    in a single system call (readlink).  Although we could use regular
  78    files to be useful on old systems lacking symlinks, nowadays
  79    virtually all such systems are probably single-user anyway, so it
  80    didn't seem worth the complication.
  81
  82    Similarly, we don't worry about a possible 14-character limit on
  83    file names, because those are all the same systems that don't have
  84    symlinks.
  85
  86    This is compatible with the locking scheme used by Interleaf (which
  87    has contributed this implementation for Emacs), and was designed by
  88    Ethan Jacobson, Kimbo Mundy, and others.
  89
  90    --karl@cs.umb.edu/karl@hq.ileaf.com.  */
  91
  92 \f
  93 /* Return the time of the last system boot.  */
  94
  95 static time_t boot_time;
  96
  97 static time_t
  98 get_boot_time ()
  99 {
 100 #ifdef BOOT_TIME
 101   struct utmp ut, *utp;
 102
 103   if (boot_time)
 104     return boot_time;
 105
 106   utmpname ("/var/log/wtmp");
 107   setutent ();
 108   boot_time = 1;
 109   while (1)
 110     {
 111       /* Find the next reboot record.  */
 112       ut.ut_type = BOOT_TIME;
 113       utp = getutid (&ut);
 114       if (! utp)
 115         break;
 116       /* Compare reboot times and use the newest one.  */
 117       if (utp->ut_time > boot_time)
 118         boot_time = utp->ut_time;
 119       /* Advance on element in the file
 120          so that getutid won't repeat the same one.  */
 121       utp = getutent ();
 122       if (! utp)
 123         break;
 124     }
 125   endutent ();
 126
 127   return boot_time;
 128 #else
 129   return 0;
 130 #endif
 131 }
 132 \f
 133 /* Here is the structure that stores information about a lock.  */
 134
 135 typedef struct
 136 {
 137   char *user;
 138   char *host;
 139   unsigned long pid;
 140   time_t boot_time;
 141 } lock_info_type;
 142
 143 /* When we read the info back, we might need this much more,
 144    enough for decimal representation plus null.  */
 145 #define LOCK_PID_MAX (4 * sizeof (unsigned long))
 146
 147 /* Free the two dynamically-allocated pieces in PTR.  */
 148 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
 149
 150
 151 /* Write the name of the lock file for FN into LFNAME.  Length will be
 152    that of FN plus two more for the leading `.#' plus one for the null.  */
 153 #define MAKE_LOCK_NAME(lock, file) \
 154   (lock = (char *) alloca (STRING_BYTES (XSTRING (file)) + 2 + 1), \
 155    fill_in_lock_file_name (lock, (file)))
 156
 157 static void
 158 fill_in_lock_file_name (lockfile, fn)
 159      register char *lockfile;
 160      register Lisp_Object fn;
 161 {
 162   register char *p;
 163
 164   strcpy (lockfile, XSTRING (fn)->data);
 165
 166   /* Shift the nondirectory part of the file name (including the null)
 167      right two characters.  Here is one of the places where we'd have to
 168      do something to support 14-character-max file names.  */
 169   for (p = lockfile + strlen (lockfile); p != lockfile && *p != '/'; p--)
 170     p[2] = *p;
 171
 172   /* Insert the `.#'.  */
 173   p[1] = '.';
 174   p[2] = '#';
 175 }
 176
 177 /* Lock the lock file named LFNAME.
 178    If FORCE is nonzero, we do so even if it is already locked.
 179    Return 1 if successful, 0 if not.  */
 180
 181 static int
 182 lock_file_1 (lfname, force)
 183      char *lfname;
 184      int force;
 185 {
 186   register int err;
 187   time_t boot_time;
 188   char *user_name;
 189   char *host_name;
 190   char *lock_info_str;
 191
 192   if (STRINGP (Fuser_login_name (Qnil)))
 193     user_name = (char *)XSTRING (Fuser_login_name (Qnil))->data;
 194   else
 195     user_name = "";
 196   if (STRINGP (Fsystem_name ()))
 197     host_name = (char *)XSTRING (Fsystem_name ())->data;
 198   else
 199     host_name = "";
 200   lock_info_str = (char *)alloca (strlen (user_name) + strlen (host_name)
 201                                   + LOCK_PID_MAX + 5);
 202
 203   boot_time = get_boot_time ();
 204   if (boot_time)
 205     sprintf (lock_info_str, "%s@%s.%lu:%lu", user_name, host_name,
 206              (unsigned long) getpid (), (unsigned long) boot_time);
 207   else
 208     sprintf (lock_info_str, "%s@%s.%lu", user_name, host_name,
 209              (unsigned long) getpid ());
 210
 211   err = symlink (lock_info_str, lfname);
 212   if (errno == EEXIST && force)
 213     {
 214       unlink (lfname);
 215       err = symlink (lock_info_str, lfname);
 216     }
 217
 218   return err == 0;
 219 }
 220
 221
 222 \f
 223 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
 224    1 if another process owns it (and set OWNER (if non-null) to info),
 225    2 if the current process owns it,
 226    or -1 if something is wrong with the locking mechanism.  */
 227
 228 static int
 229 current_lock_owner (owner, lfname)
 230      lock_info_type *owner;
 231      char *lfname;
 232 {
 233 #ifndef index
 234   extern char *rindex (), *index ();
 235 #endif
 236   int o, p, len, ret;
 237   int local_owner = 0;
 238   char *at, *dot, *colon;
 239   char *lfinfo = 0;
 240   int bufsize = 50;
 241   /* Read arbitrarily-long contents of symlink.  Similar code in
 242      file-symlink-p in fileio.c.  */
 243   do
 244     {
 245       bufsize *= 2;
 246       lfinfo = (char *) xrealloc (lfinfo, bufsize);
 247       len = readlink (lfname, lfinfo, bufsize);
 248     }
 249   while (len >= bufsize);
 250
 251   /* If nonexistent lock file, all is well; otherwise, got strange error. */
 252   if (len == -1)
 253     {
 254       xfree (lfinfo);
 255       return errno == ENOENT ? 0 : -1;
 256     }
 257
 258   /* Link info exists, so `len' is its length.  Null terminate.  */
 259   lfinfo[len] = 0;
 260
 261   /* Even if the caller doesn't want the owner info, we still have to
 262      read it to determine return value, so allocate it.  */
 263   if (!owner)
 264     {
 265       owner = (lock_info_type *) alloca (sizeof (lock_info_type));
 266       local_owner = 1;
 267     }
 268
 269   /* Parse USER@HOST.PID:BOOT_TIME.  If can't parse, return -1.  */
 270   /* The USER is everything before the first @.  */
 271   at = index (lfinfo, '@');
 272   dot = rindex (lfinfo, '.');
 273   if (!at || !dot)
 274     {
 275       xfree (lfinfo);
 276       return -1;
 277     }
 278   len = at - lfinfo;
 279   owner->user = (char *) xmalloc (len + 1);
 280   strncpy (owner->user, lfinfo, len);
 281   owner->user[len] = 0;
 282
 283   /* The PID is everything from the last `.' to the `:'.  */
 284   owner->pid = atoi (dot + 1);
 285   colon = dot;
 286   while (*colon && *colon != ':')
 287     colon++;
 288   /* After the `:', if there is one, comes the boot time.  */
 289   if (*colon == ':')
 290     owner->boot_time = atoi (colon + 1);
 291   else
 292     owner->boot_time = 0;
 293
 294   /* The host is everything in between.  */
 295   len = dot - at - 1;
 296   owner->host = (char *) xmalloc (len + 1);
 297   strncpy (owner->host, at + 1, len);
 298   owner->host[len] = 0;
 299
 300   /* We're done looking at the link info.  */
 301   xfree (lfinfo);
 302
 303   /* On current host?  */
 304   if (STRINGP (Fsystem_name ())
 305       && strcmp (owner->host, XSTRING (Fsystem_name ())->data) == 0)
 306     {
 307       if (owner->pid == getpid ())
 308         ret = 2; /* We own it.  */
 309       else if (owner->pid > 0
 310                && (kill (owner->pid, 0) >= 0 || errno == EPERM)
 311                && (owner->boot_time == 0
 312                    || owner->boot_time == get_boot_time ()))
 313         ret = 1; /* An existing process on this machine owns it.  */
 314       /* The owner process is dead or has a strange pid (<=0), so try to
 315          zap the lockfile.  */
 316       else if (unlink (lfname) < 0)
 317         ret = -1;
 318       else
 319         ret = 0;
 320     }
 321   else
 322     { /* If we wanted to support the check for stale locks on remote machines,
 323          here's where we'd do it.  */
 324       ret = 1;
 325     }
 326
 327   /* Avoid garbage.  */
 328   if (local_owner || ret <= 0)
 329     {
 330       FREE_LOCK_INFO (*owner);
 331     }
 332   return ret;
 333 }
 334
 335 \f
 336 /* Lock the lock named LFNAME if possible.
 337    Return 0 in that case.
 338    Return positive if some other process owns the lock, and info about
 339      that process in CLASHER.
 340    Return -1 if cannot lock for any other reason.  */
 341
 342 static int
 343 lock_if_free (clasher, lfname)
 344      lock_info_type *clasher;
 345      register char *lfname;
 346 {
 347   if (lock_file_1 (lfname, 0) == 0)
 348     {
 349       int locker;
 350
 351       if (errno != EEXIST)
 352         return -1;
 353
 354       locker = current_lock_owner (clasher, lfname);
 355       if (locker == 2)
 356         {
 357           FREE_LOCK_INFO (*clasher);
 358           return 0;   /* We ourselves locked it.  */
 359         }
 360       else if (locker == 1)
 361         return 1;  /* Someone else has it.  */
 362
 363       return -1; /* Something's wrong.  */
 364     }
 365   return 0;
 366 }
 367
 368 /* lock_file locks file FN,
 369    meaning it serves notice on the world that you intend to edit that file.
 370    This should be done only when about to modify a file-visiting
 371    buffer previously unmodified.
 372    Do not (normally) call this for a buffer already modified,
 373    as either the file is already locked, or the user has already
 374    decided to go ahead without locking.
 375
 376    When this returns, either the lock is locked for us,
 377    or the user has said to go ahead without locking.
 378
 379    If the file is locked by someone else, this calls
 380    ask-user-about-lock (a Lisp function) with two arguments,
 381    the file name and info about the user who did the locking.
 382    This function can signal an error, or return t meaning
 383    take away the lock, or return nil meaning ignore the lock.  */
 384
 385 void
 386 lock_file (fn)
 387      Lisp_Object fn;
 388 {
 389   register Lisp_Object attack, orig_fn, encoded_fn;
 390   register char *lfname, *locker;
 391   lock_info_type lock_info;
 392
 393   orig_fn = fn;
 394   fn = Fexpand_file_name (fn, Qnil);
 395   encoded_fn = ENCODE_FILE (fn);
 396
 397   /* Create the name of the lock-file for file fn */
 398   MAKE_LOCK_NAME (lfname, encoded_fn);
 399
 400   /* See if this file is visited and has changed on disk since it was
 401      visited.  */
 402   {
 403     register Lisp_Object subject_buf;
 404     struct gcpro gcpro1;
 405
 406     subject_buf = get_truename_buffer (orig_fn);
 407     GCPRO1 (fn);
 408
 409     if (!NILP (subject_buf)
 410         && NILP (Fverify_visited_file_modtime (subject_buf))
 411         && !NILP (Ffile_exists_p (fn)))
 412       call1 (intern ("ask-user-about-supersession-threat"), fn);
 413
 414     UNGCPRO;
 415   }
 416
 417   /* Try to lock the lock. */
 418   if (lock_if_free (&lock_info, lfname) <= 0)
 419     /* Return now if we have locked it, or if lock creation failed */
 420     return;
 421
 422   /* Else consider breaking the lock */
 423   locker = (char *) alloca (strlen (lock_info.user) + strlen (lock_info.host)
 424                             + LOCK_PID_MAX + 9);
 425   sprintf (locker, "%s@%s (pid %lu)", lock_info.user, lock_info.host,
 426            lock_info.pid);
 427   FREE_LOCK_INFO (lock_info);
 428
 429   attack = call2 (intern ("ask-user-about-lock"), fn, build_string (locker));
 430   if (!NILP (attack))
 431     /* User says take the lock */
 432     {
 433       lock_file_1 (lfname, 1);
 434       return;
 435     }
 436   /* User says ignore the lock */
 437 }
 438
 439 void
 440 unlock_file (fn)
 441      register Lisp_Object fn;
 442 {
 443   register char *lfname;
 444
 445   fn = Fexpand_file_name (fn, Qnil);
 446   fn = ENCODE_FILE (fn);
 447
 448   MAKE_LOCK_NAME (lfname, fn);
 449
 450   if (current_lock_owner (0, lfname) == 2)
 451     unlink (lfname);
 452 }
 453
 454 void
 455 unlock_all_files ()
 456 {
 457   register Lisp_Object tail;
 458   register struct buffer *b;
 459
 460   for (tail = Vbuffer_alist; GC_CONSP (tail); tail = XCONS (tail)->cdr)
 461     {
 462       b = XBUFFER (XCONS (XCONS (tail)->car)->cdr);
 463       if (STRINGP (b->file_truename) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
 464         {
 465           register char *lfname;
 466
 467           MAKE_LOCK_NAME (lfname, b->file_truename);
 468
 469           if (current_lock_owner (0, lfname) == 2)
 470             unlink (lfname);
 471         }
 472     }
 473 }
 474 \f
 475 DEFUN ("lock-buffer", Flock_buffer, Slock_buffer,
 476   0, 1, 0,
 477   "Lock FILE, if current buffer is modified.\n\
 478 FILE defaults to current buffer's visited file,\n\
 479 or else nothing is done if current buffer isn't visiting a file.")
 480   (file)
 481      Lisp_Object file;
 482 {
 483   if (NILP (file))
 484     file = current_buffer->file_truename;
 485   else
 486     CHECK_STRING (file, 0);
 487   if (SAVE_MODIFF < MODIFF
 488       && !NILP (file))
 489     lock_file (file);
 490   return Qnil;
 491 }
 492
 493 DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer,
 494   0, 0, 0,
 495  "Unlock the file visited in the current buffer,\n\
 496 if it should normally be locked.")
 497   ()
 498 {
 499   if (SAVE_MODIFF < MODIFF
 500       && STRINGP (current_buffer->file_truename))
 501     unlock_file (current_buffer->file_truename);
 502   return Qnil;
 503 }
 504
 505 /* Unlock the file visited in buffer BUFFER.  */
 506
 507 void
 508 unlock_buffer (buffer)
 509      struct buffer *buffer;
 510 {
 511   if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer)
 512       && STRINGP (buffer->file_truename))
 513     unlock_file (buffer->file_truename);
 514 }
 515
 516 DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 0, 1, 0,
 517   "Return nil if the FILENAME is not locked,\n\
 518 t if it is locked by you, else a string of the name of the locker.")
 519   (filename)
 520   Lisp_Object filename;
 521 {
 522   Lisp_Object ret;
 523   register char *lfname;
 524   int owner;
 525   lock_info_type locker;
 526
 527   filename = Fexpand_file_name (filename, Qnil);
 528
 529   MAKE_LOCK_NAME (lfname, filename);
 530
 531   owner = current_lock_owner (&locker, lfname);
 532   if (owner <= 0)
 533     ret = Qnil;
 534   else if (owner == 2)
 535     ret = Qt;
 536   else
 537     ret = build_string (locker.user);
 538
 539   if (owner > 0)
 540     FREE_LOCK_INFO (locker);
 541
 542   return ret;
 543 }
 544 \f
 545 /* Initialization functions.  */
 546
 547 void
 548 syms_of_filelock ()
 549 {
 550   defsubr (&Sunlock_buffer);
 551   defsubr (&Slock_buffer);
 552   defsubr (&Sfile_locked_p);
 553 }
 554
 555 #endif /* CLASH_DETECTION */