home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / vile-src.zip / vile-8.1 / lckfiles.c < prev    next >
C/C++ Source or Header  |  1998-04-28  |  3KB  |  106 lines
  1. /*
  2.  * lckfiles.c   set_lock() and release_lock(), for maintaining
  3.  *        little file.lck style lockfiles.  this isn't what
  4.  *        we would call a standard mechanism.  but it's simple.
  5.  *
  6.  *        it's also not completely integrated with the editor --
  7.  *        for instance, one can probably bypass the locking mechanism
  8.  *        in various ways.  it is intended as an _aid_ to multiple
  9.  *        edits.  _not_ a cure-all.  it works well for the people
  10.  *        at Baan who contributed the code.  i make no other claims
  11.  *        for it.
  12.  *
  13.  *        operation:  if the global "usefilelock" is on, then when
  14.  *        "file" is edited, a "file.lck" is created, containing the
  15.  *        username of the user doing the editing.  when a file is
  16.  *        edited for which there already exists a .lck file, the buffer
  17.  *        mode "locked" is set to true and "locker" is set to the name
  18.  *        of the user that created the .lck.  this infomation will
  19.  *        appear on the status line, as "locked by pgf", and the
  20.  *        buffer will be marked readonly.  the .lck file will be
  21.  *        deleted at most of the appropriate times.
  22.  *
  23.  * $Header: /usr/build/vile/vile/RCS/lckfiles.c,v 1.8 1998/04/28 10:17:15 tom Exp $
  24.  *
  25.  */
  26.  
  27. #include    "estruct.h"
  28. #include    "edef.h"
  29.  
  30. #if OPT_LCKFILES
  31.  
  32. #if ! HAVE_LONG_FILE_NAMES
  33. you probably do not want this code -- there are no checks on filename
  34. length when adding .lck to the end
  35. #endif
  36.  
  37. static void
  38. get_lock_owner(char *lockfile, char *who, int n)
  39. {
  40.     FILE *fp;
  41.     int l;
  42.     if ( (fp = fopen(lockfile,FOPEN_READ)) != (FILE *)0 ) {
  43.         l = read(fileno(fp),who,(SIZE_T)(n-1));
  44.         if ( l < 0 ) {
  45.             (void)strcpy(who,"'Can't read .lck'");
  46.         } else {
  47.             who[l-1] = EOS; /* Strip \n */
  48.         }
  49.         fclose(fp);
  50.     } else {
  51.         (void)strcpy(who,"'Can't open .lck'");
  52.     }
  53. }
  54.  
  55. static char *
  56. ourname(void)
  57. {
  58.     char *np;
  59.     np = getenv("LOGNAME");
  60.     if (!np) np = getenv("USER");
  61.     if (!np) np = "unknown";
  62.     return np;
  63. }
  64.  
  65. int
  66. set_lock(const char *fname, char *who, int n)
  67. {
  68.     char    lockfile[NFILEN];
  69.     FILE    *fp;
  70.  
  71.     sprintf(lockfile,"%s.lck",fname);
  72.  
  73.     if ( ffexists(lockfile)) {
  74.         /* Lockfile exists */
  75.         get_lock_owner(lockfile,who,n);
  76.         mlwrite("[%s]",who);
  77.         return FALSE;            /* Can't set lock */
  78.     } else {
  79.         if (( fp = fopen(lockfile,FOPEN_WRITE)) != (FILE *)0 ) {
  80.             (void)lsprintf(who,"%s\n",ourname());
  81.             write(fileno(fp),who,strlen(who));
  82.             fclose(fp);
  83.         } else {
  84.             (void)strcpy(who,"'Can't write .lck'");
  85.             mlwrite("[%s]",who);
  86.             return(FALSE);        /* Can't set lock */
  87.         }
  88.     }
  89.     return TRUE;                /* Lock ok */
  90. }
  91.  
  92. void release_lock(const char *fname)
  93. {
  94.     char    lockfile[NFILEN];
  95.     char    who[100];
  96.  
  97.     if ( fname && *fname ) {
  98.         (void)lsprintf(lockfile,"%s.lck",fname);
  99.         get_lock_owner(lockfile,who,sizeof(who));
  100.         /* is it ours? */
  101.         if (strcmp(who, ourname()) == 0)
  102.             unlink(lockfile);
  103.     }
  104. }
  105. #endif
  106.