See ChangeLog: Sat Jan 16 09:27:30 CET 1999 Werner Koch
[gnupg.git] / util / dotlock.c
index 42d4711..71e6178 100644 (file)
@@ -1,14 +1,14 @@
 /* dotlock.c - dotfile locking
  *     Copyright (C) 1998 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>
+#include <sys/utsname.h>
+#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"
 
 
+static int read_lockfile( const char *name );
 
-
-#if 0
 /****************
  * Create a lockfile with the given name. A TIMEOUT of 0
  * returns immediately, -1 waits forever (hopefully not), other
  *
  * 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 )
 {
-    int rc=-1, fd=-1, pid;
+    int  fd=-1, pid;
     char pidstr[16];
+    const char *handle = NULL;
+    char *lockname = NULL;
     char *tname = NULL;
-    char *p;
+    int have_tfile = 0;
+    struct utsname uts;
+    const char *nodename;
+    const char *dirpart;
+    int dirpartlen;
+    const char *maybe_dead="";
+    int backoff=0;
 
-    log_debug("dotlock_make: lock='%s'\n", lockfile );
     sprintf( pidstr, "%10d\n", getpid() );
-    /* add the hostname to the second line (FQDN or IP addr?) */
+    /* 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( &uts ) )
+       nodename = "unknown";
+    else
+       nodename = uts.nodename;
+
+    if( !(dirpart = strrchr( file_to_lock, '/' )) ) {
+       dirpart = ".";
+       dirpartlen = 1;
+    }
+    else {
+       dirpartlen = dirpart - file_to_lock;
+       dirpart = file_to_lock;
+    }
+
+  #ifdef _THREAD_SAFE
+    tname = m_alloc( dirpartlen + 6 + strlen(nodename) + 11+ 20 );
+    sprintf( tname, "%.*s/.#lk.%s.%d.%p",
+                   dirpartlen, dirpart, nodename, getpid(), &pid );
+  #else
+    tname = m_alloc( dirpartlen + 6 + strlen(nodename) + 11 );
+    sprintf( tname, "%.*s/.#lk.%s.%d",
+                   dirpartlen, dirpart, nodename, getpid() );
+  #endif
+    do {
+       errno = 0;
+       fd = open( tname, O_WRONLY|O_CREAT|O_EXCL,
+                         S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR );
+    } while( fd == -1 && errno == EINTR );
+    if( fd == -1 ) {
+       log_error( "failed to create temporary file `%s': %s\n",
+                                             tname, strerror(errno));
+       goto leave;
+    }
+    have_tfile = 1;
+    if( write(fd, pidstr, 11 ) != 11 ) {
+       log_fatal( "error writing to `%s': %s\n", tname, strerror(errno) );
+       goto leave;
+    }
     if( close(fd) ) {
-       log_fatal( "error closing '%s'\n", tname);
+       log_error( "error closing `%s': %s\n", tname, strerror(errno));
+       goto leave;
+    }
+    fd = -1;
+
+    lockname = m_alloc( strlen(file_to_lock) + 6 );
+    strcpy(stpcpy(lockname, file_to_lock), ".lock");
 
   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( !link(tname, lockname) ) {/* fixme: better use stat to check the link count */
+       handle = lockname;
+       lockname = NULL;
+    }
+    else if( errno == EEXIST ) {
+       if( (pid = read_lockfile(lockname)) == -1 ) {
            if( errno == ENOENT ) {
-               log_debug( "lockfile disappeared\n");
+               log_info( "lockfile disappeared\n");
                goto retry;
            }
-           log_debug("cannot read lockfile\n");
+           log_info("cannot read lockfile\n");
        }
        else if( pid == getpid() ) {
            log_info( "Oops: lock already hold by us\n");
-           rc = 0;  /* okay */
+           handle = lockname;
+           lockname = NULL;
        }
        else if( kill(pid, 0) && errno == ESRCH ) {
-           log_info( "removing stale lockfile (created by %d)", (int)pid );
-           remove( lockfile );
+           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 );
+           remove( lockname );
+           goto retry;
+        #endif
+       }
+       if( timeout == -1 ) {
+           struct timeval tv;
+           log_info( "waiting for lock (hold by %d%s) ...\n", pid, maybe_dead );
+           /* 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++ ;
            goto retry;
        }
-       log_debug( "lock not made: lock file exists\n" );
+       /* fixme: implement timeouts */
     }
+    else
+       log_error( "lock not made: link() failed: %s\n", strerror(errno) );
 
-    if( tname ) {
+  leave:
+    if( fd != -1 )
+       close(fd);
+    if( have_tfile )
        remove(tname);
-       free(tname);
-    }
-    if( !rc )
-       log_debug( "lock made\n");
-    return rc;
+    m_free(tname);
+    m_free(lockname);
+    return handle;
 }
 
 /****************
@@ -126,7 +193,7 @@ make_dotlock( const char *file_to_lock, long timeout )
 int
 release_dotlock( const char *lockfile )
 {
-    int pid = rad_lockfile( lockfile );
+    int pid = read_lockfile( lockfile );
     if( pid == -1 ) {
        log_error( "release_dotlock: lockfile error");
        return -1;
@@ -136,11 +203,11 @@ release_dotlock( const char *lockfile )
        return -1;
     }
     if( remove( lockfile ) ) {
-       log_error( "release_dotlock: error removing lockfile '%s'",
+       log_error( "release_dotlock: error removing lockfile `%s'",
                                                            lockfile);
        return -1;
     }
-    log_debug( "release_dotlock: released lockfile '%s'", lockfile);
+    m_free( (char*)lockfile );
     return 0;
 }
 
@@ -156,12 +223,12 @@ read_lockfile( const char *name )
 
     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 );
+       log_debug("error reading lockfile `%s'", name );
        close(fd);
        errno = 0;
        return -1;
@@ -169,10 +236,10 @@ read_lockfile( const char *name )
     close(fd);
     pid = atoi(pidstr);
     if( !pid || pid == -1 ) {
-       log_error("invalid pid %d in lockfile '%s'", pid, name );
+       log_error("invalid pid %d in lockfile `%s'", pid, name );
        errno = 0;
        return -1;
     }
     return pid;
 }
-#endif
+