From d88b75838a9264542bb4a8ee8bc9a603c4a8750f Mon Sep 17 00:00:00 2001 From: Pavel Roskin Date: Wed, 2 Apr 2003 19:36:10 +0000 Subject: [PATCH] * editlock.c, editlock.h: New files. Implement file locking in Emacs style, as documented in JED editor sources. * Makefile.am: Add those files to build tree. * edit-widget.c (WEdit): New property 'locked', 0 on edit_init. * edit.c (edit_modification): Lock buffer on modification. * editcmd.c (edit_save_cmd, edit_save_as_cmd): Handle locking during file save. (edit_load_file_from_filename): Unlock. Remove 2 duplicate lines (handled by edit_init). (edit_quit_cmd): Unlock. --- edit/ChangeLog | 14 ++++ edit/Makefile.am | 2 +- edit/edit-widget.h | 1 + edit/edit.c | 8 +- edit/editcmd.c | 61 ++++++++++++--- edit/editlock.c | 190 +++++++++++++++++++++++++++++++++++++++++++++ edit/editlock.h | 7 ++ 7 files changed, 272 insertions(+), 11 deletions(-) create mode 100644 edit/editlock.c create mode 100644 edit/editlock.h diff --git a/edit/ChangeLog b/edit/ChangeLog index 20de6f67d..3ba605bc9 100644 --- a/edit/ChangeLog +++ b/edit/ChangeLog @@ -1,3 +1,17 @@ +2003-04-01 Adam Byrtek + + * editlock.c, editlock.h: New files. Implement file locking in + Emacs style, as documented in JED editor sources. + * Makefile.am: Add those files to build tree. + + * edit-widget.c (WEdit): New property 'locked', 0 on edit_init. + * edit.c (edit_modification): Lock buffer on modification. + * editcmd.c (edit_save_cmd, edit_save_as_cmd): Handle locking + during file save. + (edit_load_file_from_filename): Unlock. Remove 2 duplicate + lines (handled by edit_init). + (edit_quit_cmd): Unlock. + 2003-03-12 Pavel Roskin * edit.h: Make it easier to tweak buffer size and maximal number diff --git a/edit/Makefile.am b/edit/Makefile.am index 3bef164e3..41516de3f 100644 --- a/edit/Makefile.am +++ b/edit/Makefile.am @@ -9,6 +9,6 @@ endif libedit_a_SOURCES = \ bookmark.c edit.c editcmd.c editwidget.c editdraw.c editkeys.c \ editmenu.c editoptions.c editcmddef.h edit.h edit-widget.h \ - syntax.c wordproc.c + editlock.c editlock.h syntax.c wordproc.c EXTRA_DIST = ChangeLog diff --git a/edit/edit-widget.h b/edit/edit-widget.h index ee55a184d..544c33d78 100644 --- a/edit/edit-widget.h +++ b/edit/edit-widget.h @@ -56,6 +56,7 @@ struct WEdit { unsigned char overwrite; unsigned char modified; /* has the file been changed?: 1 if char inserted or deleted at all since last load or save */ + unsigned char locked; /* 1 if lock is held on current file */ unsigned char screen_modified; /* has the file been changed since the last screen draw? */ int delete_file; /* Has the file been created by the editor? Delete it at end of editing when it hasn't been modified diff --git a/edit/edit.c b/edit/edit.c index 9f0029af6..bfdb517dc 100644 --- a/edit/edit.c +++ b/edit/edit.c @@ -22,6 +22,7 @@ #include #include "edit.h" +#include "editlock.h" #include "edit-widget.h" #include "editcmddef.h" @@ -554,6 +555,7 @@ edit_init (WEdit *edit, int lines, int columns, const char *filename, return 0; } edit->modified = 0; + edit->locked = 0; edit_load_syntax (edit, 0, 0); { int color; @@ -811,8 +813,12 @@ pop_action (WEdit * edit) static inline void edit_modification (WEdit * edit) { edit->caches_valid = 0; - edit->modified = 1; edit->screen_modified = 1; + + /* raise lock when file modified */ + if (!edit->modified && !edit->delete_file) + edit->locked = edit_lock_file (edit->filename); + edit->modified = 1; } /* diff --git a/edit/editcmd.c b/edit/editcmd.c index 54b271970..22eb0858b 100644 --- a/edit/editcmd.c +++ b/edit/editcmd.c @@ -27,6 +27,7 @@ #include #include "edit.h" +#include "editlock.h" #include "editcmddef.h" #include "edit-widget.h" @@ -184,9 +185,6 @@ void edit_refresh_cmd (WEdit * edit) doupdate(); } -/* "Oleg Yu. Repin" added backup filenames - ...thanks -paul */ - /* If 0 (quick save) then a) create/truncate file, b) save to ; if 1 (safe save) then a) save to , @@ -438,6 +436,7 @@ edit_save_as_cmd (WEdit *edit) { /* This heads the 'Save As' dialog box */ char *exp = 0; + int save_lock = 0; int different_filename = 0; exp = edit_get_save_file (edit->filename, _(" Save As ")); @@ -465,8 +464,25 @@ edit_save_as_cmd (WEdit *edit) return 0; } } + save_lock = edit_lock_file (exp); + } else { + /* filenames equal, check if already locked */ + if (!edit->locked && !edit->delete_file) + save_lock = edit_lock_file (exp); } + if (edit_save_file (edit, exp)) { + /* Succesful, so unlock both files */ + if (strcmp (edit->filename, exp)) { + if (save_lock) + edit_unlock_file (exp); + if (edit->locked) + edit->locked = edit_unlock_file (edit->filename); + } else { + if (edit->locked || save_lock) + edit->locked = edit_unlock_file (edit->filename); + } + edit_set_filename (edit, exp); g_free (exp); edit->modified = 0; @@ -476,6 +492,11 @@ edit_save_as_cmd (WEdit *edit) edit->force |= REDRAW_COMPLETELY; return 1; } else { + /* Failed, so maintain modify (not save) lock */ + if (strcmp (edit->filename, exp) && save_lock) + edit_unlock_file (exp); + if (save_lock) + edit->locked = edit_unlock_file (edit->filename); g_free (exp); edit_error_dialog (_(" Save As "), get_sys_error (_ @@ -730,11 +751,22 @@ int edit_save_confirm_cmd (WEdit * edit) /* returns 1 on success */ int edit_save_cmd (WEdit * edit) { - if (!edit_save_file (edit, edit->filename)) + int res, save_lock = 0; + + if (!edit->locked && !edit->delete_file) + save_lock = edit_lock_file (edit->filename); + res = edit_save_file (edit, edit->filename); + + /* Maintain modify (not save) lock on failure */ + if ((res && edit->locked) || save_lock) + edit->locked = edit_unlock_file (edit->filename); + + /* On failure try 'save as', it does locking on its own */ + if (!res) return edit_save_as_cmd (edit); edit->force |= REDRAW_COMPLETELY; - edit->modified = 0; edit->delete_file = 0; + edit->modified = 0; return 1; } @@ -750,7 +782,9 @@ int edit_new_cmd (WEdit * edit) } } edit->force |= REDRAW_COMPLETELY; - edit->modified = 0; + + if (edit->locked) + edit->locked = edit_unlock_file (edit->filename); return edit_renew (edit); /* if this gives an error, something has really screwed up */ } @@ -758,10 +792,17 @@ int edit_new_cmd (WEdit * edit) static int edit_load_file_from_filename (WEdit * edit, char *exp) { - if (!edit_reload (edit, exp)) + int prev_locked = edit->locked; + char *prev_filename = g_strdup (edit->filename); + + if (!edit_reload (edit, exp)) { + g_free (prev_filename); return 1; - edit_set_filename (edit, exp); - edit->modified = 0; + } + + if (prev_locked) + edit_unlock_file (prev_filename); + g_free (prev_filename); return 0; } @@ -2023,6 +2064,8 @@ void edit_quit_cmd (WEdit * edit) return; break; case 2: + if (edit->locked) + edit->locked = edit_unlock_file (edit->filename); if (edit->delete_file) unlink (edit->filename); break; diff --git a/edit/editlock.c b/edit/editlock.c new file mode 100644 index 000000000..004b187a4 --- /dev/null +++ b/edit/editlock.c @@ -0,0 +1,190 @@ +/* editor file locking. + + Copyright (C) 2003 the Free Software Foundation + + Authors: 2003 Adam Byrtek + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307, USA. + +*/ + +#include +#include "edit.h" +#include "editlock.h" + +#include "src/wtools.h" /* edit_query_dialog () */ + +#define BUF_SIZE 255 +#define PID_BUF_SIZE 10 + +/* Locking scheme used in mcedit is based on a documentation found + in JED editor sources. Abstract from lock.c file (by John E. Davis): + + The basic idea here is quite simple. Whenever a buffer is attached to + a file, and that buffer is modified, then attempt to lock the + file. Moreover, before writing to a file for any reason, lock the + file. The lock is really a protocol respected and not a real lock. + The protocol is this: If in the directory of the file is a + symbolic link with name ".#FILE", the FILE is considered to be locked + by the process specified by the link. +*/ + +/* Build user@host.domain.pid string (need to be freed) */ +static char * +lock_build_name (char *fname) +{ + char host[BUF_SIZE], *user; + + if (! + ((user = getpwuid (getuid ())->pw_name) || (user = getenv ("USER")) + || (user = getenv ("USERNAME")) || (user = getenv ("LOGNAME")))) + user = ""; + + /* TODO: Use FQDN, no clean interface, so requires lot of code */ + if (gethostname (host, BUF_SIZE - 1) == -1) + *host = '\0'; + + return g_strdup_printf ("%s@%s.%d", user, host, getpid ()); +} + +/* Extract pid from user@host.domain.pid string */ +static pid_t +lock_extract_pid (char *str) +{ + int i; + char *p, pid[PID_BUF_SIZE]; + + /* Treat text between '.' and ':' or '\0' as pid */ + for (p = str + strlen (str) - 1; p >= str; p--) + if (*p == '.') + break; + + i = 0; + for (p = p + 1; + p < str + strlen (str) && *p != ':' && i < PID_BUF_SIZE; p++) + pid[i++] = *p; + pid[i] = '\0'; + + return (pid_t) atol (pid); +} + +/* Extract user@host.domain.pid from lock file (static string) */ +static char * +lock_get_info (char *lockfname) +{ + int cnt; + static char buf[BUF_SIZE]; + + if ((cnt = readlink (lockfname, buf, BUF_SIZE - 1)) == -1 || !buf + || !*buf) + return NULL; + buf[cnt] = '\0'; + return buf; +} + + +/* Tries to raise file lock + Returns 1 on success, 0 on failure, -1 if abort */ +int +edit_lock_file (char *fname) +{ + char *lockfname, *newlock, *msg, *lock; + struct stat statbuf; + pid_t pid; + + /* Just to be sure (and don't lock new file) */ + if (!fname || !*fname) + return 0; + + /* Check if already locked */ + lockfname = g_strconcat (".#", fname, NULL); + if (lstat (lockfname, &statbuf) == 0) { + lock = lock_get_info (lockfname); + if (!lock) { + g_free (lockfname); + return 0; + } + pid = lock_extract_pid (lock); + + /* Check if locking process alive, ask user if required */ + if (!pid || !(kill (pid, 0) == -1 && errno == ESRCH)) { + msg = + g_strdup_printf (_("File %s is locked by lock %s"), fname, + lock); + /* TODO: Implement "Abort" - needs to rewind undo stack */ + switch (edit_query_dialog2 + (_("File locked"), msg, _("&Grab lock"), + _("&Ignore lock"))) { + case 0: + break; + case 1: + case -1: + g_free (lockfname); + g_free (msg); + return 0; + } + g_free (msg); + } + unlink (lockfname); + } + + /* Create lock symlink */ + newlock = lock_build_name (fname); + if (symlink (newlock, lockfname) == -1) { + g_free (lockfname); + g_free (newlock); + return 0; + } + + g_free (lockfname); + g_free (newlock); + return 1; +} + +/* Lowers file lock if possible + Always returns 0 to make 'lock = edit_unlock_file (f)' possible */ +int +edit_unlock_file (char *fname) +{ + char *lockfname, *lock; + struct stat statbuf; + + /* Just to be sure */ + if (!fname || !*fname) + return 0; + + lockfname = g_strconcat (".#", fname, NULL); + + /* Check if lock exists */ + if (lstat (lockfname, &statbuf) == -1) { + g_free (lockfname); + return 0; + } + + lock = lock_get_info (lockfname); + if (lock) { + /* Don't touch if lock is not ours */ + if (lock_extract_pid (lock) != getpid ()) { + g_free (lockfname); + return 0; + } + } + + /* Remove lock */ + unlink (lockfname); + g_free (lockfname); + return 0; +} diff --git a/edit/editlock.h b/edit/editlock.h new file mode 100644 index 000000000..4a3cc9966 --- /dev/null +++ b/edit/editlock.h @@ -0,0 +1,7 @@ +#ifndef __EDIT_LOCK_H +#define __EDIT_LOCK_H + +int edit_lock_file (char *fname); +int edit_unlock_file (char *fname); + +#endif /* !__EDIT_LOCK_H */