![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to filelock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src|
Return to filelock.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src |
1.1 root 1: /* Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
2:
3: This file is part of GNU Emacs.
4:
5: GNU Emacs is distributed in the hope that it will be useful,
6: but WITHOUT ANY WARRANTY. No author or distributor
7: accepts responsibility to anyone for the consequences of using it
8: or for whether it serves any particular purpose or works at all,
9: unless he says so in writing. Refer to the GNU Emacs General Public
10: License for full details.
11:
12: Everyone is granted permission to copy, modify and redistribute
13: GNU Emacs, but only under the conditions described in the
14: GNU Emacs General Public License. A copy of this license is
15: supposed to have been given to you along with GNU Emacs so you
16: can know your rights and responsibilities. It should be in a
17: file named COPYING. Among other things, the copyright notice
18: and this notice must be preserved on all copies. */
19:
20:
21: #include <sys/types.h>
22: #include <sys/stat.h>
23: #include "config.h"
24: #include "lisp.h"
25: #include "paths.h"
26: #include "buffer.h"
27: #include <pwd.h>
28: #include <errno.h>
29: #include <sys/file.h>
30: #ifdef USG
31: #include <fcntl.h>
32: #endif /* USG */
33:
34: extern int errno;
35:
36: #ifdef CLASH_DETECTION
37:
38: /* If system does not have symbolic links, it does not have lstat.
39: In that case, use ordinary stat instead. */
40:
41: #ifndef S_IFLNK
42: #define lstat stat
43: #endif
44:
45: static Lisp_Object
46: lock_file_owner_name (lfname)
47: {
48: struct stat s;
49: struct passwd *the_pw;
50: extern struct passwd *getpwuid ();
51:
52: if (lstat (lfname, &s) == 0)
53: the_pw = getpwuid (s.st_uid);
54: return (the_pw == 0 ? Qnil : build_string (the_pw->pw_name));
55: }
56:
57:
58: /* lock_file locks file fn,
59: meaning it serves notice on the world that you intend to edit that file.
60: This should be done only when about to modify a file-visiting
61: buffer previously unmodified.
62: Do not (normally) call lock_buffer for a buffer already modified,
63: as either the file is already locked, or the user has already
64: decided to go ahead without locking.
65:
66: When lock_buffer returns, either the lock is locked for us,
67: or the user has said to go ahead without locking.
68:
69: If the file is locked by someone else, lock_buffer calls
70: ask-user-about-lock (a Lisp function) with two arguments,
71: the file name and the name of the user who did the locking.
72: This function can signal an error, or return t meaning
73: take away the lock, or return nil meaning ignore the lock. */
74:
75: /* The lock file name is the file name with "/" replaced by "!"
76: and put in the Emacs lock directory. */
77: /* (ie., /ka/king/junk.tex -> /!/!ka!king!junk.tex). */
78:
79: void
80: lock_file (fn)
81: register Lisp_Object fn;
82: {
83: register Lisp_Object attack;
84: register char *lfname;
85:
86: /* Create the name of the lock-file for file fn */
87: lfname = (char *) alloca (XSTRING (fn)->size + strlen (PATH_LOCK) + 1);
88: fill_in_lock_file_name (lfname, fn);
89:
90: /* See if this file is visited and has changed on disk since it was visited. */
91: {
92: register Lisp_Object subject_buf = Fget_file_buffer (fn);
93: if (!NULL (subject_buf)
94: && NULL (Fverify_visited_file_modtime (subject_buf))
95: && !NULL (Ffile_exists_p (fn)))
96: call1 (intern ("ask-user-about-supersession-threat"), fn);
97: }
98:
99: /* Try to lock the lock. */
100: if (lock_if_free (lfname) <= 0)
101: /* Return now if we have locked it, or if lock dir does not exist */
102: return;
103:
104: /* Else consider breaking the lock */
105: attack = call2 (intern ("ask-user-about-lock"), fn,
106: lock_file_owner_name (lfname));
107: if (!NULL (attack))
108: /* User says take the lock */
109: {
110: lock_superlock (lfname);
111: lock_file_1 (lfname, O_WRONLY) ;
112: unlink (PATH_SUPERLOCK);
113: return;
114: }
115: /* User says ignore the lock */
116: }
117:
118: fill_in_lock_file_name (lockfile, fn)
119: register char *lockfile;
120: register Lisp_Object fn;
121: {
122: register char *p;
123:
124: strcpy (lockfile, PATH_LOCK);
125:
126: p = lockfile + strlen (lockfile);
127:
128: strcpy (p, XSTRING (fn)->data);
129:
130: for (; *p; p++)
131: {
132: if (*p == '/')
133: *p = '!';
134: }
135: }
136:
137: /* Lock the lock file named LFNAME.
138: If MODE is O_WRONLY, we do so even if it is already locked.
139: If MODE is O_WRONLY | O_EXCL | O_CREAT, we do so only if it is free.
140: Return 1 if successful, 0 if not. */
141:
142: int
143: lock_file_1 (lfname, mode)
144: int mode; char *lfname;
145: {
146: register int fd;
147: char buf[20];
148:
149: if ((fd = open (lfname, mode, 0666)) >= 0)
150: {
151: fchmod (fd, 0666);
152: sprintf (buf, "%d ", getpid ());
153: write (fd, buf, strlen (buf));
154: close (fd);
155: return 1;
156: }
157: else
158: return 0;
159: }
160:
161: /* Lock the lock named LFNAME if possible.
162: Return 0 in that case.
163: Return positive if lock is really locked by someone else.
164: Return -1 if cannot lock for any other reason. */
165:
166: int
167: lock_if_free (lfname)
168: register char *lfname;
169: {
170: register int clasher;
171:
172: while (lock_file_1 (lfname, O_WRONLY | O_EXCL | O_CREAT) == 0)
173: {
174: if (errno != EEXIST)
175: return -1;
176: clasher = current_lock_owner (lfname);
177: if (clasher != 0)
178: if (clasher != getpid ())
179: return (clasher);
180: else return (0);
181: /* Try again to lock it */
182: }
183: return 0;
184: }
185:
186: /* Return the pid of the process that claims to own the lock file LFNAME,
187: or 0 if nobody does or the lock is obsolete,
188: or -1 if something is wrong with the locking mechanism. */
189:
190: int
191: current_lock_owner (lfname)
192: char *lfname;
193: {
194: int owner = current_lock_owner_1 (lfname);
195: if (owner == 0 && errno == ENOENT)
196: return (0);
197: /* Is it locked by a process that exists? */
198: if (owner != 0 && (kill (owner, 0) >= 0 || errno == EPERM))
199: return (owner);
200: if (unlink (lfname) < 0)
201: return (-1);
202: return (0);
203: }
204:
205: int
206: current_lock_owner_1 (lfname)
207: char *lfname;
208: {
209: register int fd;
210: char buf[20];
211: int tem;
212:
213: fd = open (lfname, O_RDONLY, 0666);
214: if (fd < 0)
215: return 0;
216: tem = read (fd, buf, sizeof buf);
217: close (fd);
218: return (tem <= 0 ? 0 : atoi (buf));
219: }
220:
221:
222: void
223: unlock_file (fn)
224: register Lisp_Object fn;
225: {
226: register char *lfname;
227:
228: lfname = (char *) alloca (XSTRING (fn)->size + strlen (PATH_LOCK) + 1);
229: fill_in_lock_file_name (lfname, fn);
230:
231: lock_superlock (lfname);
232:
233: if (current_lock_owner_1 (lfname) == getpid ())
234: unlink (lfname);
235:
236: unlink (PATH_SUPERLOCK);
237: }
238:
239: lock_superlock (lfname)
240: char *lfname;
241: {
242: register int i, fd;
243:
244: for (i = -20; i < 0 && (fd = open (PATH_SUPERLOCK,
245: O_WRONLY | O_EXCL | O_CREAT, 0666)) < 0;
246: i++)
247: {
248: if (errno != EEXIST)
249: return;
250: sleep (1);
251: }
252: if (fd >= 0)
253: {
254: fchmod (fd, 0666);
255: write (fd, lfname, strlen (lfname));
256: close (fd);
257: }
258: }
259:
260: void
261: unlock_all_files ()
262: {
263: register Lisp_Object tail;
264: register struct buffer *b;
265:
266: for (tail = Vbuffer_alist; XGCTYPE (tail) == Lisp_Cons;
267: tail = XCONS (tail)->cdr)
268: {
269: b = XBUFFER (XCONS (XCONS (tail)->car)->cdr);
270: if (XTYPE (b->filename) == Lisp_String &&
271: b->save_modified < b->text.modified)
272: unlock_file (b->filename);
273: }
274: }
275:
276:
277: DEFUN ("lock-buffer", Flock_buffer, Slock_buffer,
278: 0, 1, 0,
279: "Locks FILE, if current buffer is modified.\n\
280: FILE defaults to current buffer's visited file,\n\
281: or else nothing is done if current buffer isn't visiting a file.")
282: (fn)
283: Lisp_Object fn;
284: {
285: if (NULL (fn))
286: fn = bf_cur->filename;
287: else
288: CHECK_STRING (fn, 0);
289: if (bf_cur->save_modified < bf_modified
290: && !NULL (fn))
291: lock_file (fn);
292: return Qnil;
293: }
294:
295: DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer,
296: 0, 0, 0,
297: "Unlocks the file visited in the current buffer,\n\
298: if it should normally be locked.")
299: ()
300: {
301: if (bf_cur->save_modified < bf_modified &&
302: XTYPE (bf_cur->filename) == Lisp_String)
303: unlock_file (bf_cur->filename);
304: return Qnil;
305: }
306:
307:
308: /* Unlock the file visited in buffer BUFFER. */
309:
310: unlock_buffer (buffer)
311: struct buffer *buffer;
312: {
313: bf_cur->text.modified = bf_modified;
314: if (buffer->save_modified < buffer->text.modified &&
315: XTYPE (buffer->filename) == Lisp_String)
316: unlock_file (buffer->filename);
317: }
318:
319: DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 0, 1, 0,
320: "Returns nil if the FILENAME is not locked,\n\
321: t if it is locked by you, else a string of the name of the locker.")
322: (fn)
323: Lisp_Object fn;
324: {
325: register char *lfname;
326: int owner;
327:
328: fn = Fexpand_file_name (fn, Qnil);
329:
330: /* Create the name of the lock-file for file filename */
331: lfname = (char *) alloca (XSTRING (fn)->size + strlen (PATH_LOCK) + 1);
332: fill_in_lock_file_name (lfname, fn);
333:
334: owner = current_lock_owner (lfname);
335: if (owner <= 0)
336: return (Qnil);
337: else if (owner == getpid ())
338: return (Qt);
339:
340: return (lock_file_owner_name (lfname));
341: }
342:
343: syms_of_filelock ()
344: {
345: defsubr (&Sunlock_buffer);
346: defsubr (&Slock_buffer);
347: defsubr (&Sfile_locked_p);
348: }
349:
350: #endif /* CLASH_DETECTION */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.