Forgot to commit this:
[gnupg.git] / util / dotlock.c
index 917b90d..fac8254 100644 (file)
@@ -1,14 +1,14 @@
 /* dotlock.c - dotfile locking
- *     Copyright (C) 1998 Free Software Foundation, Inc.
+ *     Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
  *
- * This file is part of GNUPG.
+ * This file is part of GnuPG.
  *
- * GNUPG is free software; you can redistribute it and/or modify
+ * GnuPG 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.
  *
- * GNUPG is distributed in the hope that it will be useful,
+ * GnuPG 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.
 #include <string.h>
 #include <errno.h>
 #include <ctype.h>
+#include <errno.h>
+#include <unistd.h>
+#if !defined (HAVE_DOSISH_SYSTEM)
+#include <sys/utsname.h>
+#endif
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <signal.h>
 #include "types.h"
 #include "util.h"
 #include "memory.h"
 
+struct dotlock_handle {
+    struct dotlock_handle *next;
+    char *tname;    /* name of lockfile template */
+    char *lockname; /* name of the real lockfile */
+    int locked;     /* lock status */
+    int disable;    /* locking */
+};
+
 
+static volatile DOTLOCK all_lockfiles;
+static int never_lock;
 
+static int read_lockfile( const char *name );
+
+void
+disable_dotlock(void)
+{
+    never_lock = 1;
+}
 
-#if 0
 /****************
- * Create a lockfile with the given name. A TIMEOUT of 0
- * returns immediately, -1 waits forever (hopefully not), other
- * values are timeouts in milliseconds.
- * Returns: a char pointer used as handle for release lock
- *         or NULL in case of an error.
+ * Create a lockfile with the given name and return an object of
+ * type DOTLOCK which may be used later to actually do the lock.
+ * A cleanup routine gets installed to cleanup left over locks
+ * or other files used together with the lockmechanism.
+ * Althoug the function is called dotlock, this does not necessarily
+ * mean that real lockfiles are used - the function may decide to
+ * use fcntl locking.  Calling the function with NULL only install
+ * the atexit handler and maybe used to assure that the cleanup
+ * is called after all other atexit handlers.
  *
  * Notes: This function creates a lock file in the same directory
  *       as file_to_lock with the name "file_to_lock.lock"
- *       A temporary file ".#lk.<pid>.<hostname> is used.
+ *       A temporary file ".#lk.<hostname>.pid[.threadid] is used.
  *       This function does nothing for Windoze.
  */
-const char *
-make_dotlock( const char *file_to_lock, long timeout )
+DOTLOCK
+create_dotlock( const char *file_to_lock )
 {
-    int rc=-1, fd=-1, pid;
+    static int initialized;
+    DOTLOCK h;
+    int  fd = -1;
     char pidstr[16];
-    char *tname = NULL;
-    char *p;
+  #if !defined (HAVE_DOSISH_SYSTEM)
+    struct utsname utsbuf;
+  #endif
+    const char *nodename;
+    const char *dirpart;
+    int dirpartlen;
+
+    if( !initialized ) {
+       atexit( remove_lockfiles );
+       initialized = 1;
+    }
+    if( !file_to_lock )
+       return NULL;
+
+    h = m_alloc_clear( sizeof *h );
+    if( never_lock ) {
+       h->disable = 1;
+      #ifdef _REENTRANT
+       /* fixme: aquire mutex on all_lockfiles */
+      #endif
+       h->next = all_lockfiles;
+       all_lockfiles = h;
+       return h;
+    }
 
-    log_debug("dotlock_make: lock='%s'\n", lockfile );
-    sprintf( pidstr, "%10d\n", getpid() );
-    /* add the hostname to the second line (FQDN or IP addr?) */
+
+#if !defined (HAVE_DOSISH_SYSTEM)
+    sprintf( pidstr, "%10d\n", (int)getpid() );
+    /* fixme: add the hostname to the second line (FQDN or IP addr?) */
 
     /* create a temporary file */
-    tname = CreateTmpFile2( p, ".#lk" );
-    free(p);
-    if( !tname )
-       log_fatal( "could not create temporary lock file '%s'\n");
-    log_debug( "dotlock_make: tmpname='%s'\n", tname );
-    chmod( tname, 0644 ); /* just in case an umask is set */
-    if( !(fd = open( tname, O_WRONLY )) )
-       log_fatal( "could not open temporary lock file '%s'\n", tname);
-    if( write(fd, pidstr, 11 ) != 11 )
-       log_fatal( "error writing to temporary lock file '%s'\n", tname);
+    if( uname( &utsbuf ) )
+       nodename = "unknown";
+    else
+       nodename = utsbuf.nodename;
+
+#ifdef __riscos__
+    {
+        char *iter = (char *) nodename;
+        for (; iter[0]; iter++)
+            if (iter[0] == '.')
+                iter[0] = '/';
+    }
+#endif /* __riscos__ */
+
+    if( !(dirpart = strrchr( file_to_lock, DIRSEP_C )) ) {
+       dirpart = EXTSEP_S;
+       dirpartlen = 1;
+    }
+    else {
+       dirpartlen = dirpart - file_to_lock;
+       dirpart = file_to_lock;
+    }
+
+  #ifdef _REENTRANT
+    /* fixme: aquire mutex on all_lockfiles */
+  #endif
+    h->next = all_lockfiles;
+    all_lockfiles = h;
+
+    h->tname = m_alloc( dirpartlen + 6+30+ strlen(nodename) + 11 );
+#ifndef __riscos__
+    sprintf( h->tname, "%.*s/.#lk%p.%s.%d",
+            dirpartlen, dirpart, h, nodename, (int)getpid() );
+#else /* __riscos__ */
+    sprintf( h->tname, "%.*s.lk%p/%s/%d",
+            dirpartlen, dirpart, h, nodename, (int)getpid() );
+#endif /* __riscos__ */
+
+    do {
+       errno = 0;
+       fd = open( h->tname, O_WRONLY|O_CREAT|O_EXCL,
+                         S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR );
+    } while( fd == -1 && errno == EINTR );
+    if( fd == -1 ) {
+       all_lockfiles = h->next;
+       log_error( "failed to create temporary file `%s': %s\n",
+                                           h->tname, strerror(errno));
+       m_free(h->tname);
+       m_free(h);
+       return NULL;
+    }
+    if( write(fd, pidstr, 11 ) != 11 ) {
+       all_lockfiles = h->next;
+      #ifdef _REENTRANT
+       /* release mutex */
+      #endif
+       log_fatal( "error writing to `%s': %s\n", h->tname, strerror(errno) );
+       close(fd);
+       unlink(h->tname);
+       m_free(h->tname);
+       m_free(h);
+       return NULL;
+    }
     if( close(fd) ) {
-       log_fatal( "error closing '%s'\n", tname);
-
-  retry:
-    if( !link(tname, lockfile) )
-       rc = 0; /* okay */
-    else if( errno != EEXIST )
-       log_error( "lock not made: link() failed: %s\n", strerror(errno) );
-    else { /* lock file already there */
-       if( (pid = read_lockfile(lockfile)) == -1 ) {
-           if( errno == ENOENT ) {
-               log_debug( "lockfile disappeared\n");
-               goto retry;
-           }
-           log_debug("cannot read lockfile\n");
-       }
-       else if( pid == getpid() ) {
-           log_info( "Oops: lock already hold by us\n");
-           rc = 0;  /* okay */
-       }
-       else if( kill(pid, 0) && errno == ESRCH ) {
-           log_info( "removing stale lockfile (created by %d)", (int)pid );
-           remove( lockfile );
-           goto retry;
-       }
-       log_debug( "lock not made: lock file exists\n" );
+       all_lockfiles = h->next;
+      #ifdef _REENTRANT
+       /* release mutex */
+      #endif
+       log_error( "error closing `%s': %s\n", h->tname, strerror(errno));
+       unlink(h->tname);
+       m_free(h->tname);
+       m_free(h);
+       return NULL;
     }
 
-    if( tname ) {
-       remove(tname);
-       free(tname);
+  #ifdef _REENTRANT
+    /* release mutex */
+  #endif
+#endif
+    h->lockname = m_alloc( strlen(file_to_lock) + 6 );
+    strcpy(stpcpy(h->lockname, file_to_lock), EXTSEP_S "lock");
+    return h;
+}
+
+static int
+maybe_deadlock( DOTLOCK h )
+{
+    DOTLOCK r;
+
+    for( r=all_lockfiles; r; r = r->next ) {
+       if( r != h && r->locked )
+           return 1;
     }
-    if( !rc )
-       log_debug( "lock made\n");
-    return rc;
+    return 0;
 }
 
 /****************
- * Create a lockfile for a existing file
- * Returns: a char pointer used as handle for release lock
- *         or NULL in case of an error.
- *
- * Notes: This function creates a lock file in the same directory
- *       as file_to_lock with the name "lock.<inode-no>"
- *
- * int
- * make_inodelock( const char *file_to_lock )
- *
+ * Do a lock on H. A TIMEOUT of 0 returns immediately,
+ * -1 waits forever (hopefully not), other
+ * values are timeouts in milliseconds.
+ * Returns: 0 on success
  */
+int
+make_dotlock( DOTLOCK h, long timeout )
+{
+#if defined (HAVE_DOSISH_SYSTEM)
+    return 0;
+#else
+    int  pid;
+    const char *maybe_dead="";
+    int backoff=0;
 
+    if( h->disable ) {
+       return 0;
+    }
 
+    if( h->locked ) {
+#ifndef __riscos__
+       log_debug("oops, `%s' is already locked\n", h->lockname );
+#endif /* !__riscos__ */
+       return 0;
+    }
+
+    for(;;) {
+#ifndef __riscos__
+       if( !link(h->tname, h->lockname) ) {
+           /* fixme: better use stat to check the link count */
+           h->locked = 1;
+           return 0; /* okay */
+       }
+       if( errno != EEXIST ) {
+           log_error( "lock not made: link() failed: %s\n", strerror(errno) );
+           return -1;
+       }
+#else /* __riscos__ */
+        if( !renamefile(h->tname, h->lockname) ) {
+            h->locked = 1;
+            return 0; /* okay */
+        }
+        if( errno != EEXIST ) {
+           log_error( "lock not made: rename() failed: %s\n", strerror(errno) );
+           return -1;
+        }
+#endif /* __riscos__ */
+       if( (pid = read_lockfile(h->lockname)) == -1 ) {
+           if( errno != ENOENT ) {
+               log_info("cannot read lockfile\n");
+               return -1;
+           }
+           log_info( "lockfile disappeared\n");
+           continue;
+       }
+       else if( pid == getpid() ) {
+           log_info( "Oops: lock already held by us\n");
+           h->locked = 1;
+           return 0; /* okay */
+       }
+       else if( kill(pid, 0) && errno == ESRCH ) {
+#ifndef __riscos__
+           maybe_dead = " - probably dead";
+        #if 0 /* we should not do this without checking the permissions */
+              /* and the hostname */
+           log_info( "removing stale lockfile (created by %d)", pid );
+        #endif
+#else /* __riscos__ */
+            /* we are *pretty* sure that the other task is dead and therefore
+               we remove the other lock file */
+            maybe_dead = " - probably dead - removing lock";
+            unlink(h->lockname);
+#endif /* __riscos__ */
+       }
+       if( timeout == -1 ) {
+           struct timeval tv;
+           log_info( "waiting for lock (held by %d%s) %s...\n",
+                     pid, maybe_dead, maybe_deadlock(h)? "(deadlock?) ":"");
+
+
+           /* can't use sleep, cause signals may be blocked */
+           tv.tv_sec = 1 + backoff;
+           tv.tv_usec = 0;
+           select(0, NULL, NULL, NULL, &tv);
+           if( backoff < 10 )
+               backoff++ ;
+       }
+       else
+           return -1;
+    }
+    /*not reached */
+#endif
+}
 
 
 /****************
@@ -124,24 +308,48 @@ make_dotlock( const char *file_to_lock, long timeout )
  * Returns: 0 := success
  */
 int
-release_dotlock( const char *lockfile )
+release_dotlock( DOTLOCK h )
 {
-    int pid = read_lockfile( lockfile );
+#if defined (HAVE_DOSISH_SYSTEM)
+    return 0;
+#else
+    int pid;
+
+    if( h->disable ) {
+       return 0;
+    }
+
+    if( !h->locked ) {
+       log_debug("oops, `%s' is not locked\n", h->lockname );
+       return 0;
+    }
+
+    pid = read_lockfile( h->lockname );
     if( pid == -1 ) {
-       log_error( "release_dotlock: lockfile error");
+       log_error( "release_dotlock: lockfile error\n");
        return -1;
     }
     if( pid != getpid() ) {
-       log_error( "release_dotlock: not our lock (pid=%d)", pid);
+       log_error( "release_dotlock: not our lock (pid=%d)\n", pid);
+       return -1;
+    }
+#ifndef __riscos__
+    if( unlink( h->lockname ) ) {
+       log_error( "release_dotlock: error removing lockfile `%s'",
+                                                       h->lockname);
        return -1;
     }
-    if( remove( lockfile ) ) {
-       log_error( "release_dotlock: error removing lockfile '%s'",
-                                                           lockfile);
+#else /* __riscos__ */
+    if( renamefile(h->lockname, h->tname) ) {
+       log_error( "release_dotlock: error renaming lockfile `%s' to `%s'",
+                                                       h->lockname, h->tname);
        return -1;
     }
-    log_debug( "release_dotlock: released lockfile '%s'", lockfile);
+#endif /* __riscos__ */
+    /* fixme: check that the link count is now 1 */
+    h->locked = 0;
     return 0;
+#endif
 }
 
 
@@ -151,28 +359,62 @@ release_dotlock( const char *lockfile )
 static int
 read_lockfile( const char *name )
 {
+  #if defined (HAVE_DOSISH_SYSTEM)
+    return 0;
+  #else
     int fd, pid;
     char pidstr[16];
 
     if( (fd = open(name, O_RDONLY)) == -1 ) {
        int e = errno;
-       log_debug("error opening lockfile '%s'", name );
+       log_debug("error opening lockfile `%s': %s\n", name, strerror(errno) );
        errno = e;
        return -1;
     }
-    if( read(fd, pidstr, 10 ) != 10 ) {
-       log_debug("error reading lockfile '%s'", name );
+    if( read(fd, pidstr, 10 ) != 10 ) {  /* Read 10 digits w/o newline */
+       log_debug("error reading lockfile `%s'", name );
        close(fd);
        errno = 0;
        return -1;
     }
+    pidstr[10] = 0;  /* terminate pid string */
     close(fd);
     pid = atoi(pidstr);
+#ifndef __riscos__
     if( !pid || pid == -1 ) {
-       log_error("invalid pid %d in lockfile '%s'", pid, name );
+#else /* __riscos__ */
+    if( (!pid && riscos_getpid()) || pid == -1 ) {
+#endif /* __riscos__ */
+       log_error("invalid pid %d in lockfile `%s'", pid, name );
        errno = 0;
        return -1;
     }
     return pid;
+  #endif
 }
-#endif
+
+
+void
+remove_lockfiles()
+{
+  #if !defined (HAVE_DOSISH_SYSTEM)
+    DOTLOCK h, h2;
+
+    h = all_lockfiles;
+    all_lockfiles = NULL;
+
+    while( h ) {
+       h2 = h->next;
+       if( !h->disable ) {
+           if( h->locked )
+               unlink( h->lockname );
+           unlink(h->tname);
+           m_free(h->tname);
+           m_free(h->lockname);
+       }
+       m_free(h);
+       h = h2;
+    }
+  #endif
+}
+