Mercurial > emacs
annotate src/filelock.c @ 9286:2accc8da0793
(x_clear_frame_selections, wait_for_property_change): Use new accessor macros
instead of calling XSET directly.
author | Karl Heuer <kwzh@gnu.org> |
---|---|
date | Tue, 04 Oct 1994 12:36:03 +0000 |
parents | 3f978b13dd81 |
children | e9d341f235ee |
rev | line source |
---|---|
7307 | 1 /* Copyright (C) 1985, 1986, 1987, 1993, 1994 Free Software Foundation, Inc. |
163 | 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 | |
624 | 7 the Free Software Foundation; either version 2, or (at your option) |
163 | 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, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
18 | |
19 | |
20 #include <sys/types.h> | |
21 #include <sys/stat.h> | |
4696
1fc792473491
Include <config.h> instead of "config.h".
Roland McGrath <roland@gnu.org>
parents:
4680
diff
changeset
|
22 #include <config.h> |
372 | 23 |
24 #ifdef VMS | |
559 | 25 #include "vms-pwd.h" |
372 | 26 #else |
163 | 27 #include <pwd.h> |
372 | 28 #endif |
29 | |
163 | 30 #include <errno.h> |
31 #include <sys/file.h> | |
32 #ifdef USG | |
33 #include <fcntl.h> | |
34 #endif /* USG */ | |
35 | |
36 #include "lisp.h" | |
4701
05f6a91c2801
Include <paths.h>, not "paths.h".
Roland McGrath <roland@gnu.org>
parents:
4696
diff
changeset
|
37 #include <paths.h> |
163 | 38 #include "buffer.h" |
39 | |
6300
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
40 #ifdef SYSV_SYSTEM_DIR |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
41 #include <dirent.h> |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
42 #else /* not SYSV_SYSTEM_DIR */ |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
43 #ifdef NONSYSTEM_DIR_LIBRARY |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
44 #include "ndir.h" |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
45 #else /* not NONSYSTEM_DIR_LIBRARY */ |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
46 #ifdef MSDOS |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
47 #include <dirent.h> |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
48 #else |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
49 #include <sys/dir.h> |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
50 #endif |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
51 #endif /* not NONSYSTEM_DIR_LIBRARY */ |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
52 #ifndef MSDOS |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
53 extern DIR *opendir (); |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
54 #endif /* not MSDOS */ |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
55 #endif /* not SYSV_SYSTEM_DIR */ |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
56 |
163 | 57 extern int errno; |
58 | |
624 | 59 extern char *egetenv (); |
733 | 60 extern char *strcpy (); |
624 | 61 |
8776
290f584b7bb1
(getpwuid): Test just DECLARE_GETPWUID_WITH_UID_T, not __bsdi__.
Richard M. Stallman <rms@gnu.org>
parents:
7307
diff
changeset
|
62 #ifdef DECLARE_GETPWUID_WITH_UID_T |
4618
e4a5c21eb300
(getpwuid): Declare it as in xrdb.c.
Richard M. Stallman <rms@gnu.org>
parents:
4275
diff
changeset
|
63 extern struct passwd *getpwuid (uid_t); |
e4a5c21eb300
(getpwuid): Declare it as in xrdb.c.
Richard M. Stallman <rms@gnu.org>
parents:
4275
diff
changeset
|
64 #else |
4272
41c85882768c
(getpwuid): Declare at top level, and not if __386bsd__.
Richard M. Stallman <rms@gnu.org>
parents:
3602
diff
changeset
|
65 extern struct passwd *getpwuid (); |
41c85882768c
(getpwuid): Declare at top level, and not if __386bsd__.
Richard M. Stallman <rms@gnu.org>
parents:
3602
diff
changeset
|
66 #endif |
41c85882768c
(getpwuid): Declare at top level, and not if __386bsd__.
Richard M. Stallman <rms@gnu.org>
parents:
3602
diff
changeset
|
67 |
163 | 68 #ifdef CLASH_DETECTION |
69 | |
70 /* If system does not have symbolic links, it does not have lstat. | |
71 In that case, use ordinary stat instead. */ | |
72 | |
73 #ifndef S_IFLNK | |
74 #define lstat stat | |
75 #endif | |
76 | |
624 | 77 |
78 /* The name of the directory in which we keep lock files, with a '/' | |
79 appended. */ | |
80 char *lock_path; | |
81 | |
82 /* The name of the file in the lock directory which is used to | |
83 arbitrate access to the entire directory. */ | |
84 #define SUPERLOCK_NAME "!!!SuperLock!!!" | |
85 | |
86 /* The path to the superlock file. This is SUPERLOCK_NAME appended to | |
87 lock_path. */ | |
88 char *superlock_path; | |
89 | |
90 /* Set LOCK to the name of the lock file for the filename FILE. | |
91 char *LOCK; Lisp_Object FILE; */ | |
3537
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
92 |
3602
f71f3f167365
* filelock.c: Test HAVE_LONG_FILE_NAMES, not SHORT_FILE_NAMES, to
Jim Blandy <jimb@redhat.com>
parents:
3537
diff
changeset
|
93 #ifndef HAVE_LONG_FILE_NAMES |
3537
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
94 |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
95 #define MAKE_LOCK_PATH(lock, file) \ |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
96 (lock = (char *) alloca (14 + strlen (lock_path) + 1), \ |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
97 fill_in_lock_short_file_name (lock, (file))) |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
98 |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
99 |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
100 fill_in_lock_short_file_name (lockfile, fn) |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
101 register char *lockfile; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
102 register Lisp_Object fn; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
103 { |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
104 register union |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
105 { |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
106 unsigned int word [2]; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
107 unsigned char byte [8]; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
108 } crc; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
109 register unsigned char *p, new; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
110 |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
111 /* 7-bytes cyclic code for burst correction on byte-by-byte basis. |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
112 the used polynomial is D^7 + D^6 + D^3 +1. pot@cnuce.cnr.it */ |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
113 |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
114 crc.word[0] = crc.word[1] = 0; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
115 |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
116 for (p = XSTRING (fn)->data; new = *p++; ) |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
117 { |
4680
9d56bce1534a
* filelock.c (fill_in_lock_short_file_name): corrected the crc
Francesco Potortì <pot@gnu.org>
parents:
4618
diff
changeset
|
118 new += crc.byte[6]; |
3537
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
119 crc.byte[6] = crc.byte[5] + new; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
120 crc.byte[5] = crc.byte[4]; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
121 crc.byte[4] = crc.byte[3]; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
122 crc.byte[3] = crc.byte[2] + new; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
123 crc.byte[2] = crc.byte[1]; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
124 crc.byte[1] = crc.byte[0]; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
125 crc.byte[0] = new; |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
126 } |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
127 sprintf (lockfile, "%s%.2x%.2x%.2x%.2x%.2x%.2x%.2x", lock_path, |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
128 crc.byte[0], crc.byte[1], crc.byte[2], crc.byte[3], |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
129 crc.byte[4], crc.byte[5], crc.byte[6]); |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
130 } |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
131 |
3602
f71f3f167365
* filelock.c: Test HAVE_LONG_FILE_NAMES, not SHORT_FILE_NAMES, to
Jim Blandy <jimb@redhat.com>
parents:
3537
diff
changeset
|
132 #else /* defined HAVE_LONG_FILE_NAMES */ |
3537
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
133 |
638 | 134 #define MAKE_LOCK_PATH(lock, file) \ |
624 | 135 (lock = (char *) alloca (XSTRING (file)->size + strlen (lock_path) + 1), \ |
136 fill_in_lock_file_name (lock, (file))) | |
137 | |
3537
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
138 |
624 | 139 fill_in_lock_file_name (lockfile, fn) |
140 register char *lockfile; | |
141 register Lisp_Object fn; | |
142 { | |
143 register char *p; | |
144 | |
145 strcpy (lockfile, lock_path); | |
146 | |
147 p = lockfile + strlen (lockfile); | |
148 | |
149 strcpy (p, XSTRING (fn)->data); | |
150 | |
151 for (; *p; p++) | |
152 { | |
153 if (*p == '/') | |
154 *p = '!'; | |
155 } | |
156 } | |
3602
f71f3f167365
* filelock.c: Test HAVE_LONG_FILE_NAMES, not SHORT_FILE_NAMES, to
Jim Blandy <jimb@redhat.com>
parents:
3537
diff
changeset
|
157 #endif /* !defined HAVE_LONG_FILE_NAMES */ |
624 | 158 |
163 | 159 static Lisp_Object |
160 lock_file_owner_name (lfname) | |
161 char *lfname; | |
162 { | |
163 struct stat s; | |
164 struct passwd *the_pw; | |
165 | |
166 if (lstat (lfname, &s) == 0) | |
167 the_pw = getpwuid (s.st_uid); | |
168 return (the_pw == 0 ? Qnil : build_string (the_pw->pw_name)); | |
169 } | |
170 | |
171 | |
172 /* lock_file locks file fn, | |
173 meaning it serves notice on the world that you intend to edit that file. | |
174 This should be done only when about to modify a file-visiting | |
175 buffer previously unmodified. | |
176 Do not (normally) call lock_buffer for a buffer already modified, | |
177 as either the file is already locked, or the user has already | |
178 decided to go ahead without locking. | |
179 | |
180 When lock_buffer returns, either the lock is locked for us, | |
181 or the user has said to go ahead without locking. | |
182 | |
183 If the file is locked by someone else, lock_buffer calls | |
184 ask-user-about-lock (a Lisp function) with two arguments, | |
185 the file name and the name of the user who did the locking. | |
186 This function can signal an error, or return t meaning | |
187 take away the lock, or return nil meaning ignore the lock. */ | |
188 | |
189 /* The lock file name is the file name with "/" replaced by "!" | |
190 and put in the Emacs lock directory. */ | |
191 /* (ie., /ka/king/junk.tex -> /!/!ka!king!junk.tex). */ | |
192 | |
3602
f71f3f167365
* filelock.c: Test HAVE_LONG_FILE_NAMES, not SHORT_FILE_NAMES, to
Jim Blandy <jimb@redhat.com>
parents:
3537
diff
changeset
|
193 /* If HAVE_LONG_FILE_NAMES is not defined, the lock file name is the hex |
3537
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
194 representation of a 14-bytes CRC generated from the file name |
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
195 and put in the Emacs lock directory (not very nice, but it works). |
4680
9d56bce1534a
* filelock.c (fill_in_lock_short_file_name): corrected the crc
Francesco Potortì <pot@gnu.org>
parents:
4618
diff
changeset
|
196 (ie., /ka/king/junk.tex -> /!/12a82c62f1c6da). */ |
3537
22055fd47b78
(MAKE_LOCK_PATH): If SHORT_FILE_NAMES allocates
Richard M. Stallman <rms@gnu.org>
parents:
2961
diff
changeset
|
197 |
163 | 198 void |
199 lock_file (fn) | |
200 register Lisp_Object fn; | |
201 { | |
202 register Lisp_Object attack; | |
203 register char *lfname; | |
204 | |
624 | 205 MAKE_LOCK_PATH (lfname, fn); |
163 | 206 |
624 | 207 /* See if this file is visited and has changed on disk since it was |
208 visited. */ | |
163 | 209 { |
6499
e0bef61003ae
(lock_file): Use assignment, not initialization.
Karl Heuer <kwzh@gnu.org>
parents:
6300
diff
changeset
|
210 register Lisp_Object subject_buf; |
e0bef61003ae
(lock_file): Use assignment, not initialization.
Karl Heuer <kwzh@gnu.org>
parents:
6300
diff
changeset
|
211 subject_buf = Fget_file_buffer (fn); |
485 | 212 if (!NILP (subject_buf) |
213 && NILP (Fverify_visited_file_modtime (subject_buf)) | |
214 && !NILP (Ffile_exists_p (fn))) | |
163 | 215 call1 (intern ("ask-user-about-supersession-threat"), fn); |
216 } | |
217 | |
218 /* Try to lock the lock. */ | |
219 if (lock_if_free (lfname) <= 0) | |
220 /* Return now if we have locked it, or if lock dir does not exist */ | |
221 return; | |
222 | |
223 /* Else consider breaking the lock */ | |
224 attack = call2 (intern ("ask-user-about-lock"), fn, | |
225 lock_file_owner_name (lfname)); | |
485 | 226 if (!NILP (attack)) |
163 | 227 /* User says take the lock */ |
228 { | |
229 lock_superlock (lfname); | |
230 lock_file_1 (lfname, O_WRONLY) ; | |
624 | 231 unlink (superlock_path); |
163 | 232 return; |
233 } | |
234 /* User says ignore the lock */ | |
235 } | |
236 | |
237 /* Lock the lock file named LFNAME. | |
238 If MODE is O_WRONLY, we do so even if it is already locked. | |
239 If MODE is O_WRONLY | O_EXCL | O_CREAT, we do so only if it is free. | |
240 Return 1 if successful, 0 if not. */ | |
241 | |
242 int | |
243 lock_file_1 (lfname, mode) | |
244 int mode; char *lfname; | |
245 { | |
246 register int fd; | |
247 char buf[20]; | |
248 | |
249 if ((fd = open (lfname, mode, 0666)) >= 0) | |
250 { | |
251 #ifdef USG | |
252 chmod (lfname, 0666); | |
253 #else | |
254 fchmod (fd, 0666); | |
255 #endif | |
256 sprintf (buf, "%d ", getpid ()); | |
257 write (fd, buf, strlen (buf)); | |
258 close (fd); | |
259 return 1; | |
260 } | |
261 else | |
262 return 0; | |
263 } | |
264 | |
265 /* Lock the lock named LFNAME if possible. | |
266 Return 0 in that case. | |
267 Return positive if lock is really locked by someone else. | |
268 Return -1 if cannot lock for any other reason. */ | |
269 | |
270 int | |
271 lock_if_free (lfname) | |
272 register char *lfname; | |
273 { | |
274 register int clasher; | |
275 | |
276 while (lock_file_1 (lfname, O_WRONLY | O_EXCL | O_CREAT) == 0) | |
277 { | |
278 if (errno != EEXIST) | |
279 return -1; | |
280 clasher = current_lock_owner (lfname); | |
281 if (clasher != 0) | |
282 if (clasher != getpid ()) | |
283 return (clasher); | |
284 else return (0); | |
285 /* Try again to lock it */ | |
286 } | |
287 return 0; | |
288 } | |
289 | |
290 /* Return the pid of the process that claims to own the lock file LFNAME, | |
291 or 0 if nobody does or the lock is obsolete, | |
292 or -1 if something is wrong with the locking mechanism. */ | |
293 | |
294 int | |
295 current_lock_owner (lfname) | |
296 char *lfname; | |
297 { | |
298 int owner = current_lock_owner_1 (lfname); | |
299 if (owner == 0 && errno == ENOENT) | |
300 return (0); | |
301 /* Is it locked by a process that exists? */ | |
302 if (owner != 0 && (kill (owner, 0) >= 0 || errno == EPERM)) | |
303 return (owner); | |
304 if (unlink (lfname) < 0) | |
305 return (-1); | |
306 return (0); | |
307 } | |
308 | |
309 int | |
310 current_lock_owner_1 (lfname) | |
311 char *lfname; | |
312 { | |
313 register int fd; | |
314 char buf[20]; | |
315 int tem; | |
316 | |
317 fd = open (lfname, O_RDONLY, 0666); | |
318 if (fd < 0) | |
319 return 0; | |
320 tem = read (fd, buf, sizeof buf); | |
321 close (fd); | |
322 return (tem <= 0 ? 0 : atoi (buf)); | |
323 } | |
324 | |
325 | |
326 void | |
327 unlock_file (fn) | |
328 register Lisp_Object fn; | |
329 { | |
330 register char *lfname; | |
331 | |
624 | 332 MAKE_LOCK_PATH (lfname, fn); |
163 | 333 |
334 lock_superlock (lfname); | |
335 | |
336 if (current_lock_owner_1 (lfname) == getpid ()) | |
337 unlink (lfname); | |
338 | |
624 | 339 unlink (superlock_path); |
163 | 340 } |
341 | |
342 lock_superlock (lfname) | |
343 char *lfname; | |
344 { | |
345 register int i, fd; | |
6300
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
346 DIR *lockdir; |
163 | 347 |
624 | 348 for (i = -20; i < 0 && (fd = open (superlock_path, |
163 | 349 O_WRONLY | O_EXCL | O_CREAT, 0666)) < 0; |
350 i++) | |
351 { | |
352 if (errno != EEXIST) | |
353 return; | |
6300
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
354 |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
355 /* This seems to be necessary to prevent Emacs from hanging when the |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
356 competing process has already deleted the superlock, but it's still |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
357 in the NFS cache. So we force NFS to synchronize the cache. */ |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
358 if (lockdir = opendir (lock_path)) |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
359 closedir (lockdir); |
0aa51282fbfe
(lock_superlock): Synchronize NFS cache.
Karl Heuer <kwzh@gnu.org>
parents:
4701
diff
changeset
|
360 |
163 | 361 sleep (1); |
362 } | |
363 if (fd >= 0) | |
364 { | |
365 #ifdef USG | |
624 | 366 chmod (superlock_path, 0666); |
163 | 367 #else |
368 fchmod (fd, 0666); | |
369 #endif | |
370 write (fd, lfname, strlen (lfname)); | |
371 close (fd); | |
372 } | |
373 } | |
374 | |
375 void | |
376 unlock_all_files () | |
377 { | |
378 register Lisp_Object tail; | |
379 register struct buffer *b; | |
380 | |
381 for (tail = Vbuffer_alist; XGCTYPE (tail) == Lisp_Cons; | |
382 tail = XCONS (tail)->cdr) | |
383 { | |
384 b = XBUFFER (XCONS (XCONS (tail)->car)->cdr); | |
9130
3f978b13dd81
(unlock_all_files, Funlock_buffer, unlock_buffer): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
8776
diff
changeset
|
385 if (STRINGP (b->filename) && b->save_modified < BUF_MODIFF (b)) |
163 | 386 unlock_file (b->filename); |
387 } | |
388 } | |
389 | |
390 | |
391 DEFUN ("lock-buffer", Flock_buffer, Slock_buffer, | |
392 0, 1, 0, | |
393 "Lock FILE, if current buffer is modified.\n\ | |
394 FILE defaults to current buffer's visited file,\n\ | |
395 or else nothing is done if current buffer isn't visiting a file.") | |
396 (fn) | |
397 Lisp_Object fn; | |
398 { | |
485 | 399 if (NILP (fn)) |
163 | 400 fn = current_buffer->filename; |
401 else | |
402 CHECK_STRING (fn, 0); | |
403 if (current_buffer->save_modified < MODIFF | |
485 | 404 && !NILP (fn)) |
163 | 405 lock_file (fn); |
406 return Qnil; | |
407 } | |
408 | |
409 DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer, | |
410 0, 0, 0, | |
411 "Unlock the file visited in the current buffer,\n\ | |
412 if it should normally be locked.") | |
413 () | |
414 { | |
415 if (current_buffer->save_modified < MODIFF && | |
9130
3f978b13dd81
(unlock_all_files, Funlock_buffer, unlock_buffer): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
8776
diff
changeset
|
416 STRINGP (current_buffer->filename)) |
163 | 417 unlock_file (current_buffer->filename); |
418 return Qnil; | |
419 } | |
420 | |
421 | |
422 /* Unlock the file visited in buffer BUFFER. */ | |
423 | |
424 unlock_buffer (buffer) | |
425 struct buffer *buffer; | |
426 { | |
427 if (buffer->save_modified < BUF_MODIFF (buffer) && | |
9130
3f978b13dd81
(unlock_all_files, Funlock_buffer, unlock_buffer): Use type test macros.
Karl Heuer <kwzh@gnu.org>
parents:
8776
diff
changeset
|
428 STRINGP (buffer->filename)) |
163 | 429 unlock_file (buffer->filename); |
430 } | |
431 | |
432 DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 0, 1, 0, | |
433 "Return nil if the FILENAME is not locked,\n\ | |
434 t if it is locked by you, else a string of the name of the locker.") | |
435 (fn) | |
436 Lisp_Object fn; | |
437 { | |
438 register char *lfname; | |
439 int owner; | |
440 | |
441 fn = Fexpand_file_name (fn, Qnil); | |
442 | |
624 | 443 MAKE_LOCK_PATH (lfname, fn); |
163 | 444 |
445 owner = current_lock_owner (lfname); | |
446 if (owner <= 0) | |
447 return (Qnil); | |
448 else if (owner == getpid ()) | |
449 return (Qt); | |
450 | |
451 return (lock_file_owner_name (lfname)); | |
452 } | |
453 | |
624 | 454 |
455 /* Initialization functions. */ | |
456 | |
457 init_filelock () | |
458 { | |
459 lock_path = egetenv ("EMACSLOCKDIR"); | |
460 if (! lock_path) | |
461 lock_path = PATH_LOCK; | |
462 | |
463 /* Make sure it ends with a slash. */ | |
464 if (lock_path[strlen (lock_path) - 1] != '/') | |
465 { | |
4618
e4a5c21eb300
(getpwuid): Declare it as in xrdb.c.
Richard M. Stallman <rms@gnu.org>
parents:
4275
diff
changeset
|
466 char *new_path = (char *) xmalloc (strlen (lock_path) + 2); |
e4a5c21eb300
(getpwuid): Declare it as in xrdb.c.
Richard M. Stallman <rms@gnu.org>
parents:
4275
diff
changeset
|
467 strcpy (new_path, lock_path); |
e4a5c21eb300
(getpwuid): Declare it as in xrdb.c.
Richard M. Stallman <rms@gnu.org>
parents:
4275
diff
changeset
|
468 lock_path = new_path; |
624 | 469 strcat (lock_path, "/"); |
470 } | |
471 | |
472 superlock_path = (char *) xmalloc ((strlen (lock_path) | |
473 + sizeof (SUPERLOCK_NAME))); | |
474 strcpy (superlock_path, lock_path); | |
475 strcat (superlock_path, SUPERLOCK_NAME); | |
476 } | |
477 | |
163 | 478 syms_of_filelock () |
479 { | |
480 defsubr (&Sunlock_buffer); | |
481 defsubr (&Slock_buffer); | |
482 defsubr (&Sfile_locked_p); | |
483 } | |
484 | |
485 #endif /* CLASH_DETECTION */ |