lib/lock.c

   1 /*
   2    File locking
   3
   4    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2011
   5    The Free Software Foundation, Inc.
   6
   7    Written by:
   8    Adam Byrtek, 2003
   9
  10    This file is part of the Midnight Commander.
  11
  12    The Midnight Commander is free software: you can redistribute it
  13    and/or modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation, either version 3 of the License,
  15    or (at your option) any later version.
  16
  17    The Midnight Commander is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 /** \file
  27  *  \brief Source: file locking
  28  *  \author Adam Byrtek
  29  *  \date 2003
  30  *
  31  *  Locking scheme is based on a documentation found
  32  *  in JED editor sources. Abstract from lock.c file (by John E. Davis):
  33  *
  34  *  The basic idea here is quite simple.  Whenever a buffer is attached to
  35  *  a file, and that buffer is modified, then attempt to lock the
  36  *  file. Moreover, before writing to a file for any reason, lock the
  37  *  file. The lock is really a protocol respected and not a real lock.
  38  *  The protocol is this: If in the directory of the file is a
  39  *  symbolic link with name ".#FILE", the FILE is considered to be locked
  40  *  by the process specified by the link.
  41  */
  42
  43 #include <config.h>
  44
  45 #include <signal.h>             /* kill() */
  46 #include <stdio.h>
  47 #include <stdarg.h>
  48 #include <sys/types.h>
  49 #include <unistd.h>
  50 #include <string.h>
  51 #include <ctype.h>
  52 #include <errno.h>
  53 #include <sys/stat.h>
  54 #include <pwd.h>
  55 #include <stdlib.h>
  56
  57 #include "lib/global.h"
  58 #include "lib/vfs/vfs.h"
  59 #include "lib/util.h"           /* tilde_expand() */
  60 #include "lib/lock.h"
  61 #include "lib/widget.h"         /* query_dialog() */
  62
  63 /*** global variables ****************************************************************************/
  64
  65 /*** file scope macro definitions ****************************************************************/
  66
  67 #define BUF_SIZE 255
  68 #define PID_BUF_SIZE 10
  69
  70 /*** file scope type declarations ****************************************************************/
  71
  72 struct lock_s
  73 {
  74     char *who;
  75     pid_t pid;
  76 };
  77
  78 /*** file scope variables ************************************************************************/
  79
  80 /*** file scope functions ************************************************************************/
  81 /* --------------------------------------------------------------------------------------------- */
  82 /** \fn static char * lock_build_name (void)
  83  *  \brief builds user@host.domain.pid string (need to be freed)
  84  *  \return a pointer to lock filename
  85  */
  86
  87 static char *
  88 lock_build_name (void)
  89 {
  90     char host[BUF_SIZE];
  91     const char *user = NULL;
  92     struct passwd *pw;
  93
  94     pw = getpwuid (getuid ());
  95     if (pw)
  96         user = pw->pw_name;
  97     if (!user)
  98         user = getenv ("USER");
  99     if (!user)
 100         user = getenv ("USERNAME");
 101     if (!user)
 102         user = getenv ("LOGNAME");
 103     if (!user)
 104         user = "";
 105
 106     /** \todo Use FQDN, no clean interface, so requires lot of code */
 107     if (gethostname (host, BUF_SIZE - 1) == -1)
 108         *host = '\0';
 109
 110     return g_strdup_printf ("%s@%s.%d", user, host, (int) getpid ());
 111 }
 112
 113 /* --------------------------------------------------------------------------------------------- */
 114
 115 static char *
 116 lock_build_symlink_name (const char *fname)
 117 {
 118     char *fname_copy, *symlink_name;
 119     char absolute_fname[PATH_MAX];
 120
 121     if (mc_realpath (fname, absolute_fname) == NULL)
 122         return NULL;
 123
 124     fname = x_basename (absolute_fname);
 125     fname_copy = g_strdup (fname);
 126     absolute_fname[fname - absolute_fname] = '\0';
 127     symlink_name = g_strconcat (absolute_fname, ".#", fname_copy, (char *) NULL);
 128     g_free (fname_copy);
 129
 130     return symlink_name;
 131 }
 132
 133 /* --------------------------------------------------------------------------------------------- */
 134 /**
 135  * Extract pid from user@host.domain.pid string
 136  */
 137
 138 static struct lock_s *
 139 lock_extract_info (const char *str)
 140 {
 141     size_t i, len;
 142     const char *p, *s;
 143     static char pid[PID_BUF_SIZE], who[BUF_SIZE];
 144     static struct lock_s lock;
 145
 146     len = strlen (str);
 147
 148     for (p = str + len - 1; p >= str; p--)
 149         if (*p == '.')
 150             break;
 151
 152     /* Everything before last '.' is user@host */
 153     i = 0;
 154     for (s = str; s < p && i < BUF_SIZE; s++)
 155         who[i++] = *s;
 156     who[i] = '\0';
 157
 158     /* Treat text between '.' and ':' or '\0' as pid */
 159     i = 0;
 160     for (p = p + 1; (p < str + len) && (*p != ':') && (i < PID_BUF_SIZE); p++)
 161         pid[i++] = *p;
 162     pid[i] = '\0';
 163
 164     lock.pid = (pid_t) atol (pid);
 165     lock.who = who;
 166     return &lock;
 167 }
 168
 169 /* --------------------------------------------------------------------------------------------- */
 170 /**
 171  * Extract user@host.domain.pid from lock file (static string)
 172  */
 173
 174 static char *
 175 lock_get_info (const char *lockfname)
 176 {
 177     int cnt;
 178     static char buf[BUF_SIZE];
 179
 180     cnt = readlink (lockfname, buf, BUF_SIZE - 1);
 181     if (cnt == -1 || *buf == '\0')
 182         return NULL;
 183     buf[cnt] = '\0';
 184     return buf;
 185 }
 186
 187 /* --------------------------------------------------------------------------------------------- */
 188 /*** public functions ****************************************************************************/
 189 /* --------------------------------------------------------------------------------------------- */
 190
 191 /* Tries to raise file lock
 192    Returns 1 on success,  0 on failure, -1 if abort
 193    Warning: Might do screen refresh and lose edit->force */
 194
 195 int
 196 lock_file (const char *fname)
 197 {
 198     char *lockfname, *newlock, *msg, *lock;
 199     struct stat statbuf;
 200     struct lock_s *lockinfo;
 201     gboolean symlink_ok;
 202     vfs_path_t *vpath;
 203
 204     /* Just to be sure (and don't lock new file) */
 205     if (fname == NULL || *fname == '\0')
 206         return 0;
 207
 208     fname = tilde_expand (fname);
 209
 210     vpath = vfs_path_from_str (fname);
 211
 212     /* Locking on VFS is not supported */
 213     if (!vfs_file_is_local (vpath))
 214     {
 215         g_free ((gpointer) fname);
 216         vfs_path_free (vpath);
 217         return 0;
 218     }
 219     vfs_path_free (vpath);
 220
 221     /* Check if already locked */
 222     lockfname = lock_build_symlink_name (fname);
 223     g_free ((gpointer) fname);
 224     if (lockfname == NULL)
 225         return 0;
 226
 227     if (lstat (lockfname, &statbuf) == 0)
 228     {
 229         lock = lock_get_info (lockfname);
 230         if (lock == NULL)
 231         {
 232             g_free (lockfname);
 233             return 0;
 234         }
 235         lockinfo = lock_extract_info (lock);
 236
 237         /* Check if locking process alive, ask user if required */
 238         if (lockinfo->pid == 0 || !(kill (lockinfo->pid, 0) == -1 && errno == ESRCH))
 239         {
 240             msg =
 241                 g_strdup_printf (_
 242                                  ("File \"%s\" is already being edited.\n"
 243                                   "User: %s\nProcess ID: %d"), x_basename (lockfname) + 2,
 244                                  lockinfo->who, (int) lockinfo->pid);
 245             /* TODO: Implement "Abort" - needs to rewind undo stack */
 246             switch (query_dialog
 247                     (_("File locked"), msg, D_NORMAL, 2, _("&Grab lock"), _("&Ignore lock")))
 248             {
 249             case 0:
 250                 break;
 251             case 1:
 252             case -1:
 253                 g_free (lockfname);
 254                 g_free (msg);
 255                 return 0;
 256             }
 257             g_free (msg);
 258         }
 259         unlink (lockfname);
 260     }
 261
 262     /* Create lock symlink */
 263     newlock = lock_build_name ();
 264     symlink_ok = (symlink (newlock, lockfname) != -1);
 265     g_free (newlock);
 266     g_free (lockfname);
 267
 268     return symlink_ok ? 1 : 0;
 269 }
 270
 271 /* --------------------------------------------------------------------------------------------- */
 272 /**
 273  * Lowers file lock if possible
 274  * @returns  Always 0
 275  */
 276
 277 int
 278 unlock_file (const char *fname)
 279 {
 280     char *lockfname, *lock;
 281     struct stat statbuf;
 282
 283     /* Just to be sure */
 284     if (fname == NULL || *fname == '\0')
 285         return 0;
 286
 287     fname = tilde_expand (fname);
 288     lockfname = lock_build_symlink_name (fname);
 289     g_free ((gpointer) fname);
 290
 291     if (lockfname == NULL)
 292         return 0;
 293
 294     /* Check if lock exists */
 295     if (lstat (lockfname, &statbuf) == -1)
 296     {
 297         g_free (lockfname);
 298         return 0;
 299     }
 300
 301     lock = lock_get_info (lockfname);
 302     if (lock != NULL)
 303     {
 304         /* Don't touch if lock is not ours */
 305         if (lock_extract_info (lock)->pid != getpid ())
 306         {
 307             g_free (lockfname);
 308             return 0;
 309         }
 310     }
 311
 312     /* Remove lock */
 313     unlink (lockfname);
 314     g_free (lockfname);
 315     return 0;
 316 }
 317
 318 /* --------------------------------------------------------------------------------------------- */