lib-src/emacsclient.c (min): Undef before redefining it.
[emacs.git] / src / filelock.c
blob2613eec4aca44917c3abda08d57ffb0496680f4c
1 /* Lock files for editing.
2 Copyright (C) 1985-1987, 1993-1994, 1996, 1998-2012
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #include <signal.h>
25 #include <stdio.h>
26 #include <setjmp.h>
28 #ifdef HAVE_PWD_H
29 #include <pwd.h>
30 #endif
32 #include <sys/file.h>
33 #include <fcntl.h>
34 #include <unistd.h>
36 #ifdef __FreeBSD__
37 #include <sys/sysctl.h>
38 #endif /* __FreeBSD__ */
40 #include <errno.h>
42 #include "lisp.h"
43 #include "buffer.h"
44 #include "character.h"
45 #include "coding.h"
46 #include "systime.h"
48 #ifdef CLASH_DETECTION
50 #ifdef HAVE_UTMP_H
51 #include <utmp.h>
52 #endif
54 /* A file whose last-modified time is just after the most recent boot.
55 Define this to be NULL to disable checking for this file. */
56 #ifndef BOOT_TIME_FILE
57 #define BOOT_TIME_FILE "/var/run/random-seed"
58 #endif
60 #ifndef WTMP_FILE
61 #define WTMP_FILE "/var/log/wtmp"
62 #endif
64 /* The strategy: to lock a file FN, create a symlink .#FN in FN's
65 directory, with link data `user@host.pid'. This avoids a single
66 mount (== failure) point for lock files.
68 When the host in the lock data is the current host, we can check if
69 the pid is valid with kill.
71 Otherwise, we could look at a separate file that maps hostnames to
72 reboot times to see if the remote pid can possibly be valid, since we
73 don't want Emacs to have to communicate via pipes or sockets or
74 whatever to other processes, either locally or remotely; rms says
75 that's too unreliable. Hence the separate file, which could
76 theoretically be updated by daemons running separately -- but this
77 whole idea is unimplemented; in practice, at least in our
78 environment, it seems such stale locks arise fairly infrequently, and
79 Emacs' standard methods of dealing with clashes suffice.
81 We use symlinks instead of normal files because (1) they can be
82 stored more efficiently on the filesystem, since the kernel knows
83 they will be small, and (2) all the info about the lock can be read
84 in a single system call (readlink). Although we could use regular
85 files to be useful on old systems lacking symlinks, nowadays
86 virtually all such systems are probably single-user anyway, so it
87 didn't seem worth the complication.
89 Similarly, we don't worry about a possible 14-character limit on
90 file names, because those are all the same systems that don't have
91 symlinks.
93 This is compatible with the locking scheme used by Interleaf (which
94 has contributed this implementation for Emacs), and was designed by
95 Ethan Jacobson, Kimbo Mundy, and others.
97 --karl@cs.umb.edu/karl@hq.ileaf.com. */
100 /* Return the time of the last system boot. */
102 static time_t boot_time;
103 static int boot_time_initialized;
105 #ifdef BOOT_TIME
106 static void get_boot_time_1 (const char *, int);
107 #endif
109 static time_t
110 get_boot_time (void)
112 #if defined (BOOT_TIME)
113 int counter;
114 #endif
116 if (boot_time_initialized)
117 return boot_time;
118 boot_time_initialized = 1;
120 #if defined (CTL_KERN) && defined (KERN_BOOTTIME)
122 int mib[2];
123 size_t size;
124 struct timeval boottime_val;
126 mib[0] = CTL_KERN;
127 mib[1] = KERN_BOOTTIME;
128 size = sizeof (boottime_val);
130 if (sysctl (mib, 2, &boottime_val, &size, NULL, 0) >= 0)
132 boot_time = boottime_val.tv_sec;
133 return boot_time;
136 #endif /* defined (CTL_KERN) && defined (KERN_BOOTTIME) */
138 if (BOOT_TIME_FILE)
140 struct stat st;
141 if (stat (BOOT_TIME_FILE, &st) == 0)
143 boot_time = st.st_mtime;
144 return boot_time;
148 #if defined (BOOT_TIME)
149 #ifndef CANNOT_DUMP
150 /* The utmp routines maintain static state.
151 Don't touch that state unless we are initialized,
152 since it might not survive dumping. */
153 if (! initialized)
154 return boot_time;
155 #endif /* not CANNOT_DUMP */
157 /* Try to get boot time from utmp before wtmp,
158 since utmp is typically much smaller than wtmp.
159 Passing a null pointer causes get_boot_time_1
160 to inspect the default file, namely utmp. */
161 get_boot_time_1 ((char *) 0, 0);
162 if (boot_time)
163 return boot_time;
165 /* Try to get boot time from the current wtmp file. */
166 get_boot_time_1 (WTMP_FILE, 1);
168 /* If we did not find a boot time in wtmp, look at wtmp, and so on. */
169 for (counter = 0; counter < 20 && ! boot_time; counter++)
171 char cmd_string[sizeof WTMP_FILE ".19.gz"];
172 Lisp_Object tempname, filename;
173 int delete_flag = 0;
175 filename = Qnil;
177 sprintf (cmd_string, "%s.%d", WTMP_FILE, counter);
178 tempname = build_string (cmd_string);
179 if (! NILP (Ffile_exists_p (tempname)))
180 filename = tempname;
181 else
183 sprintf (cmd_string, "%s.%d.gz", WTMP_FILE, counter);
184 tempname = build_string (cmd_string);
185 if (! NILP (Ffile_exists_p (tempname)))
187 Lisp_Object args[6];
189 /* The utmp functions on mescaline.gnu.org accept only
190 file names up to 8 characters long. Choose a 2
191 character long prefix, and call make_temp_file with
192 second arg non-zero, so that it will add not more
193 than 6 characters to the prefix. */
194 filename = Fexpand_file_name (build_string ("wt"),
195 Vtemporary_file_directory);
196 filename = make_temp_name (filename, 1);
197 args[0] = build_string ("gzip");
198 args[1] = Qnil;
199 args[2] = list2 (QCfile, filename);
200 args[3] = Qnil;
201 args[4] = build_string ("-cd");
202 args[5] = tempname;
203 Fcall_process (6, args);
204 delete_flag = 1;
208 if (! NILP (filename))
210 get_boot_time_1 (SSDATA (filename), 1);
211 if (delete_flag)
212 unlink (SSDATA (filename));
216 return boot_time;
217 #else
218 return 0;
219 #endif
222 #ifdef BOOT_TIME
223 /* Try to get the boot time from wtmp file FILENAME.
224 This succeeds if that file contains a reboot record.
226 If FILENAME is zero, use the same file as before;
227 if no FILENAME has ever been specified, this is the utmp file.
228 Use the newest reboot record if NEWEST is nonzero,
229 the first reboot record otherwise.
230 Ignore all reboot records on or before BOOT_TIME.
231 Success is indicated by setting BOOT_TIME to a larger value. */
233 void
234 get_boot_time_1 (const char *filename, int newest)
236 struct utmp ut, *utp;
237 int desc;
239 if (filename)
241 /* On some versions of IRIX, opening a nonexistent file name
242 is likely to crash in the utmp routines. */
243 desc = emacs_open (filename, O_RDONLY, 0);
244 if (desc < 0)
245 return;
247 emacs_close (desc);
249 utmpname (filename);
252 setutent ();
254 while (1)
256 /* Find the next reboot record. */
257 ut.ut_type = BOOT_TIME;
258 utp = getutid (&ut);
259 if (! utp)
260 break;
261 /* Compare reboot times and use the newest one. */
262 if (utp->ut_time > boot_time)
264 boot_time = utp->ut_time;
265 if (! newest)
266 break;
268 /* Advance on element in the file
269 so that getutid won't repeat the same one. */
270 utp = getutent ();
271 if (! utp)
272 break;
274 endutent ();
276 #endif /* BOOT_TIME */
278 /* Here is the structure that stores information about a lock. */
280 typedef struct
282 char *user;
283 char *host;
284 pid_t pid;
285 time_t boot_time;
286 } lock_info_type;
288 /* Free the two dynamically-allocated pieces in PTR. */
289 #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0)
292 /* Write the name of the lock file for FN into LFNAME. Length will be
293 that of FN plus two more for the leading `.#' plus 1 for the
294 trailing period plus one for the digit after it plus one for the
295 null. */
296 #define MAKE_LOCK_NAME(lock, file) \
297 (lock = (char *) alloca (SBYTES (file) + 2 + 1 + 1 + 1), \
298 fill_in_lock_file_name (lock, (file)))
300 static void
301 fill_in_lock_file_name (register char *lockfile, register Lisp_Object fn)
303 register char *p;
304 struct stat st;
305 int count = 0;
307 strcpy (lockfile, SSDATA (fn));
309 /* Shift the nondirectory part of the file name (including the null)
310 right two characters. Here is one of the places where we'd have to
311 do something to support 14-character-max file names. */
312 for (p = lockfile + strlen (lockfile); p != lockfile && *p != '/'; p--)
313 p[2] = *p;
315 /* Insert the `.#'. */
316 p[1] = '.';
317 p[2] = '#';
319 p = p + strlen (p);
321 while (lstat (lockfile, &st) == 0 && !S_ISLNK (st.st_mode))
323 if (count > 9)
325 *p = '\0';
326 return;
328 sprintf (p, ".%d", count++);
332 /* Lock the lock file named LFNAME.
333 If FORCE is nonzero, we do so even if it is already locked.
334 Return 1 if successful, 0 if not. */
336 static int
337 lock_file_1 (char *lfname, int force)
339 register int err;
340 printmax_t boot, pid;
341 const char *user_name;
342 const char *host_name;
343 char *lock_info_str;
344 ptrdiff_t lock_info_size;
345 int symlink_errno;
346 USE_SAFE_ALLOCA;
348 /* Call this first because it can GC. */
349 boot = get_boot_time ();
351 if (STRINGP (Fuser_login_name (Qnil)))
352 user_name = SSDATA (Fuser_login_name (Qnil));
353 else
354 user_name = "";
355 if (STRINGP (Fsystem_name ()))
356 host_name = SSDATA (Fsystem_name ());
357 else
358 host_name = "";
359 lock_info_size = (strlen (user_name) + strlen (host_name)
360 + 2 * INT_STRLEN_BOUND (printmax_t)
361 + sizeof "@.:");
362 SAFE_ALLOCA (lock_info_str, char *, lock_info_size);
363 pid = getpid ();
365 esprintf (lock_info_str, boot ? "%s@%s.%"pMd":%"pMd : "%s@%s.%"pMd,
366 user_name, host_name, pid, boot);
368 err = symlink (lock_info_str, lfname);
369 if (errno == EEXIST && force)
371 unlink (lfname);
372 err = symlink (lock_info_str, lfname);
375 symlink_errno = errno;
376 SAFE_FREE ();
377 errno = symlink_errno;
378 return err == 0;
381 /* Return 1 if times A and B are no more than one second apart. */
383 static int
384 within_one_second (time_t a, time_t b)
386 return (a - b >= -1 && a - b <= 1);
389 /* Return 0 if nobody owns the lock file LFNAME or the lock is obsolete,
390 1 if another process owns it (and set OWNER (if non-null) to info),
391 2 if the current process owns it,
392 or -1 if something is wrong with the locking mechanism. */
394 static int
395 current_lock_owner (lock_info_type *owner, char *lfname)
397 int ret;
398 ptrdiff_t len;
399 lock_info_type local_owner;
400 intmax_t n;
401 char *at, *dot, *colon;
402 char readlink_buf[READLINK_BUFSIZE];
403 char *lfinfo = emacs_readlink (lfname, readlink_buf);
405 /* If nonexistent lock file, all is well; otherwise, got strange error. */
406 if (!lfinfo)
407 return errno == ENOENT ? 0 : -1;
409 /* Even if the caller doesn't want the owner info, we still have to
410 read it to determine return value. */
411 if (!owner)
412 owner = &local_owner;
414 /* Parse USER@HOST.PID:BOOT_TIME. If can't parse, return -1. */
415 /* The USER is everything before the last @. */
416 at = strrchr (lfinfo, '@');
417 dot = strrchr (lfinfo, '.');
418 if (!at || !dot)
420 if (lfinfo != readlink_buf)
421 xfree (lfinfo);
422 return -1;
424 len = at - lfinfo;
425 owner->user = (char *) xmalloc (len + 1);
426 memcpy (owner->user, lfinfo, len);
427 owner->user[len] = 0;
429 /* The PID is everything from the last `.' to the `:'. */
430 errno = 0;
431 n = strtoimax (dot + 1, NULL, 10);
432 owner->pid =
433 ((0 <= n && n <= TYPE_MAXIMUM (pid_t)
434 && (TYPE_MAXIMUM (pid_t) < INTMAX_MAX || errno != ERANGE))
435 ? n : 0);
437 colon = strchr (dot + 1, ':');
438 /* After the `:', if there is one, comes the boot time. */
439 n = 0;
440 if (colon)
442 errno = 0;
443 n = strtoimax (colon + 1, NULL, 10);
445 owner->boot_time =
446 ((0 <= n && n <= TYPE_MAXIMUM (time_t)
447 && (TYPE_MAXIMUM (time_t) < INTMAX_MAX || errno != ERANGE))
448 ? n : 0);
450 /* The host is everything in between. */
451 len = dot - at - 1;
452 owner->host = (char *) xmalloc (len + 1);
453 memcpy (owner->host, at + 1, len);
454 owner->host[len] = 0;
456 /* We're done looking at the link info. */
457 if (lfinfo != readlink_buf)
458 xfree (lfinfo);
460 /* On current host? */
461 if (STRINGP (Fsystem_name ())
462 && strcmp (owner->host, SSDATA (Fsystem_name ())) == 0)
464 if (owner->pid == getpid ())
465 ret = 2; /* We own it. */
466 else if (owner->pid > 0
467 && (kill (owner->pid, 0) >= 0 || errno == EPERM)
468 && (owner->boot_time == 0
469 || within_one_second (owner->boot_time, get_boot_time ())))
470 ret = 1; /* An existing process on this machine owns it. */
471 /* The owner process is dead or has a strange pid (<=0), so try to
472 zap the lockfile. */
473 else if (unlink (lfname) < 0)
474 ret = -1;
475 else
476 ret = 0;
478 else
479 { /* If we wanted to support the check for stale locks on remote machines,
480 here's where we'd do it. */
481 ret = 1;
484 /* Avoid garbage. */
485 if (owner == &local_owner || ret <= 0)
487 FREE_LOCK_INFO (*owner);
489 return ret;
493 /* Lock the lock named LFNAME if possible.
494 Return 0 in that case.
495 Return positive if some other process owns the lock, and info about
496 that process in CLASHER.
497 Return -1 if cannot lock for any other reason. */
499 static int
500 lock_if_free (lock_info_type *clasher, register char *lfname)
502 while (lock_file_1 (lfname, 0) == 0)
504 int locker;
506 if (errno != EEXIST)
507 return -1;
509 locker = current_lock_owner (clasher, lfname);
510 if (locker == 2)
512 FREE_LOCK_INFO (*clasher);
513 return 0; /* We ourselves locked it. */
515 else if (locker == 1)
516 return 1; /* Someone else has it. */
517 else if (locker == -1)
518 return -1; /* current_lock_owner returned strange error. */
520 /* We deleted a stale lock; try again to lock the file. */
522 return 0;
525 /* lock_file locks file FN,
526 meaning it serves notice on the world that you intend to edit that file.
527 This should be done only when about to modify a file-visiting
528 buffer previously unmodified.
529 Do not (normally) call this for a buffer already modified,
530 as either the file is already locked, or the user has already
531 decided to go ahead without locking.
533 When this returns, either the lock is locked for us,
534 or the user has said to go ahead without locking.
536 If the file is locked by someone else, this calls
537 ask-user-about-lock (a Lisp function) with two arguments,
538 the file name and info about the user who did the locking.
539 This function can signal an error, or return t meaning
540 take away the lock, or return nil meaning ignore the lock. */
542 void
543 lock_file (Lisp_Object fn)
545 register Lisp_Object attack, orig_fn, encoded_fn;
546 register char *lfname, *locker;
547 ptrdiff_t locker_size;
548 lock_info_type lock_info;
549 printmax_t pid;
550 struct gcpro gcpro1;
551 USE_SAFE_ALLOCA;
553 /* Don't do locking while dumping Emacs.
554 Uncompressing wtmp files uses call-process, which does not work
555 in an uninitialized Emacs. */
556 if (! NILP (Vpurify_flag))
557 return;
559 orig_fn = fn;
560 GCPRO1 (fn);
561 fn = Fexpand_file_name (fn, Qnil);
562 encoded_fn = ENCODE_FILE (fn);
564 /* Create the name of the lock-file for file fn */
565 MAKE_LOCK_NAME (lfname, encoded_fn);
567 /* See if this file is visited and has changed on disk since it was
568 visited. */
570 register Lisp_Object subject_buf;
572 subject_buf = get_truename_buffer (orig_fn);
574 if (!NILP (subject_buf)
575 && NILP (Fverify_visited_file_modtime (subject_buf))
576 && !NILP (Ffile_exists_p (fn)))
577 call1 (intern ("ask-user-about-supersession-threat"), fn);
580 UNGCPRO;
582 /* Try to lock the lock. */
583 if (lock_if_free (&lock_info, lfname) <= 0)
584 /* Return now if we have locked it, or if lock creation failed */
585 return;
587 /* Else consider breaking the lock */
588 locker_size = (strlen (lock_info.user) + strlen (lock_info.host)
589 + INT_STRLEN_BOUND (printmax_t)
590 + sizeof "@ (pid )");
591 SAFE_ALLOCA (locker, char *, locker_size);
592 pid = lock_info.pid;
593 esprintf (locker, "%s@%s (pid %"pMd")",
594 lock_info.user, lock_info.host, pid);
595 FREE_LOCK_INFO (lock_info);
597 attack = call2 (intern ("ask-user-about-lock"), fn, build_string (locker));
598 SAFE_FREE ();
599 if (!NILP (attack))
600 /* User says take the lock */
602 lock_file_1 (lfname, 1);
603 return;
605 /* User says ignore the lock */
608 void
609 unlock_file (register Lisp_Object fn)
611 register char *lfname;
613 fn = Fexpand_file_name (fn, Qnil);
614 fn = ENCODE_FILE (fn);
616 MAKE_LOCK_NAME (lfname, fn);
618 if (current_lock_owner (0, lfname) == 2)
619 unlink (lfname);
622 void
623 unlock_all_files (void)
625 register Lisp_Object tail;
626 register struct buffer *b;
628 for (tail = Vbuffer_alist; CONSP (tail); tail = XCDR (tail))
630 b = XBUFFER (XCDR (XCAR (tail)));
631 if (STRINGP (BVAR (b, file_truename)) && BUF_SAVE_MODIFF (b) < BUF_MODIFF (b))
633 unlock_file (BVAR (b, file_truename));
638 DEFUN ("lock-buffer", Flock_buffer, Slock_buffer,
639 0, 1, 0,
640 doc: /* Lock FILE, if current buffer is modified.
641 FILE defaults to current buffer's visited file,
642 or else nothing is done if current buffer isn't visiting a file. */)
643 (Lisp_Object file)
645 if (NILP (file))
646 file = BVAR (current_buffer, file_truename);
647 else
648 CHECK_STRING (file);
649 if (SAVE_MODIFF < MODIFF
650 && !NILP (file))
651 lock_file (file);
652 return Qnil;
655 DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer,
656 0, 0, 0,
657 doc: /* Unlock the file visited in the current buffer.
658 If the buffer is not modified, this does nothing because the file
659 should not be locked in that case. */)
660 (void)
662 if (SAVE_MODIFF < MODIFF
663 && STRINGP (BVAR (current_buffer, file_truename)))
664 unlock_file (BVAR (current_buffer, file_truename));
665 return Qnil;
668 /* Unlock the file visited in buffer BUFFER. */
670 void
671 unlock_buffer (struct buffer *buffer)
673 if (BUF_SAVE_MODIFF (buffer) < BUF_MODIFF (buffer)
674 && STRINGP (BVAR (buffer, file_truename)))
675 unlock_file (BVAR (buffer, file_truename));
678 DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 1, 1, 0,
679 doc: /* Return a value indicating whether FILENAME is locked.
680 The value is nil if the FILENAME is not locked,
681 t if it is locked by you, else a string saying which user has locked it. */)
682 (Lisp_Object filename)
684 Lisp_Object ret;
685 register char *lfname;
686 int owner;
687 lock_info_type locker;
689 filename = Fexpand_file_name (filename, Qnil);
691 MAKE_LOCK_NAME (lfname, filename);
693 owner = current_lock_owner (&locker, lfname);
694 if (owner <= 0)
695 ret = Qnil;
696 else if (owner == 2)
697 ret = Qt;
698 else
699 ret = build_string (locker.user);
701 if (owner > 0)
702 FREE_LOCK_INFO (locker);
704 return ret;
707 /* Initialization functions. */
709 void
710 init_filelock (void)
712 boot_time = 0;
713 boot_time_initialized = 0;
716 #endif /* CLASH_DETECTION */
718 void
719 syms_of_filelock (void)
721 DEFVAR_LISP ("temporary-file-directory", Vtemporary_file_directory,
722 doc: /* The directory for writing temporary files. */);
723 Vtemporary_file_directory = Qnil;
725 #ifdef CLASH_DETECTION
726 defsubr (&Sunlock_buffer);
727 defsubr (&Slock_buffer);
728 defsubr (&Sfile_locked_p);
729 #endif