![[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 [Apple XNU] / GNUtools / emacs / src|
Return to filelock.c CVS log | Up to [Apple XNU] / GNUtools / emacs / 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 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
18:
19:
20: #include <sys/types.h>
21: #include <sys/stat.h>
22: #include "config.h"
23: #ifdef hpux
24: /* needed by <pwd.h> */
25: #include <stdio.h>
26: #undef NULL
27: #endif
28: #include "lisp.h"
29: #include "paths.h"
30: #include "buffer.h"
31:
32: #ifdef VMS
33: #include "vms-pwd.h"
34: #else
35: #include <pwd.h>
36: #endif
37:
38: #include <errno.h>
39: #include <sys/file.h>
40: #ifdef USG
41: #include <fcntl.h>
42: #endif /* USG */
43:
44: #include "filetypes.h"
45:
46: extern int errno;
47:
48: #ifdef VMS
49: /* Prevent the file from being totally empty. */
50: static dummy () {}
51: #endif
52:
53: #ifdef CLASH_DETECTION
54:
55: /* If system does not have symbolic links, it does not have lstat.
56: In that case, use ordinary stat instead. */
57:
58: #ifndef S_IFLNK
59: #define lstat stat
60: #endif
61:
62: static Lisp_Object
63: lock_file_owner_name (lfname)
64: char *lfname;
65: {
66: struct stat s;
67: struct passwd *the_pw;
68: extern struct passwd *getpwuid ();
69:
70: if (lstat (lfname, &s) == 0)
71: the_pw = getpwuid (s.st_uid);
72: return (the_pw == 0 ? Qnil : build_string (the_pw->pw_name));
73: }
74:
75:
76: /* lock_file locks file fn,
77: meaning it serves notice on the world that you intend to edit that file.
78: This should be done only when about to modify a file-visiting
79: buffer previously unmodified.
80: Do not (normally) call lock_buffer for a buffer already modified,
81: as either the file is already locked, or the user has already
82: decided to go ahead without locking.
83:
84: When lock_buffer returns, either the lock is locked for us,
85: or the user has said to go ahead without locking.
86:
87: If the file is locked by someone else, lock_buffer calls
88: ask-user-about-lock (a Lisp function) with two arguments,
89: the file name and the name of the user who did the locking.
90: This function can signal an error, or return t meaning
91: take away the lock, or return nil meaning ignore the lock. */
92:
93: /* The lock file name is the file name with "/" replaced by "!"
94: and put in the Emacs lock directory. */
95: /* (ie., /ka/king/junk.tex -> /!/!ka!king!junk.tex). */
96:
97: /* If SHORT_FILE_NAMES is defined, the lock file name is the hex
98: representation of a 14-bytes CRC generated from the file name
99: and put in the Emacs lock directory (not very nice, but it works).
100: (ie., /ka/king/junk.tex -> /!/ec92d3ed24a8f0). */
101:
102: #ifdef SHORT_FILE_NAMES
103:
104: # define CREATE_LOCK_FILE_NAME(lfname, fn) \
105: { lfname = (char *) alloca (14 + strlen (PATH_LOCK) + 1); \
106: fill_in_lock_short_file_name (lfname, fn); }
107:
108: #else
109:
110: # define CREATE_LOCK_FILE_NAME(lfname, fn) \
111: { lfname = (char *) alloca (XSTRING (fn)->size + strlen (PATH_LOCK) + 1); \
112: fill_in_lock_file_name (lfname, fn); }
113:
114: #endif
115:
116:
117:
118: void
119: lock_file (fn)
120: register Lisp_Object fn;
121: {
122: register Lisp_Object attack;
123: register char *lfname;
124:
125: /* Create the name of the lock-file for file fn */
126: CREATE_LOCK_FILE_NAME (lfname, fn);
127:
128: /* See if this file is visited and has changed on disk since it was visited. */
129: {
130: register Lisp_Object subject_buf = Fget_file_buffer (fn);
131: if (!NULL (subject_buf)
132: && NULL (Fverify_visited_file_modtime (subject_buf))
133: && !NULL (Ffile_exists_p (fn)))
134: call1 (intern ("ask-user-about-supersession-threat"), fn);
135: }
136:
137: /* Try to lock the lock. */
138: if (lock_if_free (lfname) <= 0)
139: /* Return now if we have locked it, or if lock dir does not exist */
140: return;
141:
142: /* Else consider breaking the lock */
143: attack = call2 (intern ("ask-user-about-lock"), fn,
144: lock_file_owner_name (lfname));
145: if (!NULL (attack))
146: /* User says take the lock */
147: {
148: lock_superlock (lfname);
149: lock_file_1 (lfname, O_WRONLY) ;
150: unlink (PATH_SUPERLOCK);
151: return;
152: }
153: /* User says ignore the lock */
154: }
155:
156: fill_in_lock_file_name (lockfile, fn)
157: register char *lockfile;
158: register Lisp_Object fn;
159: {
160: register char *p;
161:
162: strcpy (lockfile, PATH_LOCK);
163:
164: p = lockfile + strlen (lockfile);
165:
166: strcpy (p, XSTRING (fn)->data);
167:
168: for (; *p; p++)
169: {
170: if (*p == '/')
171: *p = '!';
172: }
173: }
174:
175: #ifdef SHORT_FILE_NAMES
176: fill_in_lock_short_file_name (lockfile, fn)
177: register char *lockfile;
178: register Lisp_Object fn;
179: {
180: register union
181: {
182: unsigned int word [2];
183: unsigned char byte [8];
184: } crc;
185: register unsigned char *p, new;
186:
187: /* 7-bytes cyclic code for burst correction on byte-by-byte basis.
188: the used polynomial is D^7 + D^6 + D^3 +1. [email protected] */
189:
190: crc.word[0] = crc.word[1] = 0;
191:
192: for (p = XSTRING (fn)->data; new = *p++; )
193: {
194: new += crc.byte[7];
195: crc.byte[7] = crc.byte[6];
196: crc.byte[6] = crc.byte[5] + new;
197: crc.byte[5] = crc.byte[4];
198: crc.byte[4] = crc.byte[3];
199: crc.byte[3] = crc.byte[2] + new;
200: crc.byte[2] = crc.byte[1];
201: crc.byte[1] = crc.byte[0];
202: crc.byte[0] = new;
203: }
204: sprintf (lockfile, "%s%.2x%.2x%.2x%.2x%.2x%.2x%.2x", PATH_LOCK,
205: crc.byte[0], crc.byte[1], crc.byte[2], crc.byte[3],
206: crc.byte[4], crc.byte[5], crc.byte[6]);
207: }
208: #endif /* SHORT_FILE_NAMES */
209:
210: /* Lock the lock file named LFNAME.
211: If MODE is O_WRONLY, we do so even if it is already locked.
212: If MODE is O_WRONLY | O_EXCL | O_CREAT, we do so only if it is free.
213: Return 1 if successful, 0 if not. */
214:
215: int
216: lock_file_1 (lfname, mode)
217: int mode; char *lfname;
218: {
219: register int fd;
220: char buf[20];
221:
222: if ((fd = open (lfname, mode, 0666)) >= 0)
223: {
224: #ifdef NO_FCHMOD
225: chmod (lfname, 0666);
226: #else
227: fchmod (fd, 0666);
228: #endif
229: sprintf (buf, "%d ", getpid ());
230: write (fd, buf, strlen (buf));
231: close (fd);
232: return 1;
233: }
234: else
235: return 0;
236: }
237:
238: /* Lock the lock named LFNAME if possible.
239: Return 0 in that case.
240: Return positive if lock is really locked by someone else.
241: Return -1 if cannot lock for any other reason. */
242:
243: int
244: lock_if_free (lfname)
245: register char *lfname;
246: {
247: register int clasher;
248:
249: while (lock_file_1 (lfname, O_WRONLY | O_EXCL | O_CREAT) == 0)
250: {
251: if (errno != EEXIST)
252: return -1;
253: clasher = current_lock_owner (lfname);
254: if (clasher != 0)
255: if (clasher != getpid ())
256: return (clasher);
257: else return (0);
258: /* Try again to lock it */
259: }
260: return 0;
261: }
262:
263: /* Return the pid of the process that claims to own the lock file LFNAME,
264: or 0 if nobody does or the lock is obsolete,
265: or -1 if something is wrong with the locking mechanism. */
266:
267: int
268: current_lock_owner (lfname)
269: char *lfname;
270: {
271: int owner = current_lock_owner_1 (lfname);
272: if (owner == 0 && errno == ENOENT)
273: return (0);
274: /* Is it locked by a process that exists? */
275: if (owner != 0 && (kill (owner, 0) >= 0 || errno == EPERM))
276: return (owner);
277: if (unlink (lfname) < 0)
278: return (-1);
279: return (0);
280: }
281:
282: int
283: current_lock_owner_1 (lfname)
284: char *lfname;
285: {
286: register int fd;
287: char buf[20];
288: int tem;
289:
290: fd = open (lfname, O_RDONLY, 0666);
291: if (fd < 0)
292: return 0;
293: tem = read (fd, buf, sizeof buf);
294: close (fd);
295: return (tem <= 0 ? 0 : atoi (buf));
296: }
297:
298:
299: void
300: unlock_file (fn)
301: register Lisp_Object fn;
302: {
303: register char *lfname;
304:
305: CREATE_LOCK_FILE_NAME (lfname, fn);
306:
307: lock_superlock (lfname);
308:
309: if (current_lock_owner_1 (lfname) == getpid ())
310: unlink (lfname);
311:
312: unlink (PATH_SUPERLOCK);
313: }
314:
315: lock_superlock (lfname)
316: char *lfname;
317: {
318: register int i, fd;
319:
320: for (i = -20; i < 0 && (fd = open (PATH_SUPERLOCK,
321: O_WRONLY | O_EXCL | O_CREAT, 0666)) < 0;
322: i++)
323: {
324: if (errno != EEXIST)
325: return;
326: sleep (1);
327: }
328: if (fd >= 0)
329: {
330: #ifdef NO_FCHMOD
331: chmod (PATH_SUPERLOCK, 0666);
332: #else
333: fchmod (fd, 0666);
334: #endif
335: write (fd, lfname, strlen (lfname));
336: close (fd);
337: }
338: }
339:
340: void
341: unlock_all_files ()
342: {
343: register Lisp_Object tail;
344: register struct buffer *b;
345:
346: for (tail = Vbuffer_alist; XGCTYPE (tail) == Lisp_Cons;
347: tail = XCONS (tail)->cdr)
348: {
349: b = XBUFFER (XCONS (XCONS (tail)->car)->cdr);
350: if (XTYPE (b->filename) == Lisp_String &&
351: b->save_modified < BUF_MODIFF (b))
352: unlock_file (b->filename);
353: }
354: }
355:
356:
357: DEFUN ("lock-buffer", Flock_buffer, Slock_buffer,
358: 0, 1, 0,
359: "Locks FILE, if current buffer is modified.\n\
360: FILE defaults to current buffer's visited file,\n\
361: or else nothing is done if current buffer isn't visiting a file.")
362: (fn)
363: Lisp_Object fn;
364: {
365: if (NULL (fn))
366: fn = current_buffer->filename;
367: else
368: CHECK_STRING (fn, 0);
369: if (current_buffer->save_modified < MODIFF
370: && !NULL (fn))
371: lock_file (fn);
372: return Qnil;
373: }
374:
375: DEFUN ("unlock-buffer", Funlock_buffer, Sunlock_buffer,
376: 0, 0, 0,
377: "Unlocks the file visited in the current buffer,\n\
378: if it should normally be locked.")
379: ()
380: {
381: if (current_buffer->save_modified < MODIFF &&
382: XTYPE (current_buffer->filename) == Lisp_String)
383: unlock_file (current_buffer->filename);
384: return Qnil;
385: }
386:
387:
388: /* Unlock the file visited in buffer BUFFER. */
389:
390: unlock_buffer (buffer)
391: struct buffer *buffer;
392: {
393: if (buffer->save_modified < BUF_MODIFF (buffer)
394: && XTYPE (buffer->filename) == Lisp_String)
395: unlock_file (buffer->filename);
396: }
397:
398: DEFUN ("file-locked-p", Ffile_locked_p, Sfile_locked_p, 0, 1, 0,
399: "Returns nil if the FILENAME is not locked,\n\
400: t if it is locked by you, else a string of the name of the locker.")
401: (fn)
402: Lisp_Object fn;
403: {
404: register char *lfname;
405: int owner;
406:
407: fn = Fexpand_file_name (fn, Qnil);
408:
409: /* Create the name of the lock-file for file filename */
410: CREATE_LOCK_FILE_NAME (lfname, fn);
411:
412: owner = current_lock_owner (lfname);
413: if (owner <= 0)
414: return (Qnil);
415: else if (owner == getpid ())
416: return (Qt);
417:
418: return (lock_file_owner_name (lfname));
419: }
420:
421: syms_of_filelock ()
422: {
423: defsubr (&Sunlock_buffer);
424: defsubr (&Slock_buffer);
425: defsubr (&Sfile_locked_p);
426: }
427:
428: #endif /* CLASH_DETECTION */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.