mirror of
git://git.gnupg.org/gnupg.git
synced 2024-12-23 10:29:58 +01:00
c0c2c58054
to libgcrypt functions, using shared error codes from libgpg-error, replacing the old functions we used to have in ../util by those in ../jnlib and ../common, renaming the malloc functions and a couple of types. Note, that not all changes are listed below becuause they are too similar and done at far too many places. As of today the code builds using the current libgcrypt from CVS but it is very unlikely that it actually works.
421 lines
9.9 KiB
C
421 lines
9.9 KiB
C
/* dotlock.c - dotfile locking
|
|
* Copyright (C) 1998,2000,2001,2003 Free Software Foundation, Inc.
|
|
*
|
|
* This file is part of GnuPG.
|
|
*
|
|
* 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,
|
|
* 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 <config.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#ifndef 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 "libjnlib-config.h"
|
|
#include "dotlock.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;
|
|
}
|
|
|
|
/****************
|
|
* 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.<hostname>.pid[.threadid] is used.
|
|
* This function does nothing for Windoze.
|
|
*/
|
|
DOTLOCK
|
|
create_dotlock( const char *file_to_lock )
|
|
{
|
|
static int initialized;
|
|
DOTLOCK h;
|
|
int fd = -1;
|
|
char pidstr[16];
|
|
#ifndef HAVE_DOSISH_SYSTEM
|
|
struct utsname utsbuf;
|
|
#endif
|
|
const char *nodename;
|
|
const char *dirpart;
|
|
int dirpartlen;
|
|
|
|
if( !initialized ) {
|
|
atexit( dotlock_remove_lockfiles );
|
|
initialized = 1;
|
|
}
|
|
if( !file_to_lock )
|
|
return NULL;
|
|
|
|
h = jnlib_xcalloc( 1, 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;
|
|
}
|
|
|
|
#ifndef 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 */
|
|
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 = jnlib_xmalloc( 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));
|
|
jnlib_free(h->tname);
|
|
jnlib_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);
|
|
jnlib_free(h->tname);
|
|
jnlib_free(h);
|
|
return NULL;
|
|
}
|
|
if( close(fd) ) {
|
|
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);
|
|
jnlib_free(h->tname);
|
|
jnlib_free(h);
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef _REENTRANT
|
|
/* release mutex */
|
|
#endif
|
|
#endif /* !HAVE_DOSISH_SYSTEM */
|
|
h->lockname = jnlib_xmalloc( 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;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/****************
|
|
* 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 )
|
|
{
|
|
#ifdef 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 /* !HAVE_DOSISH_SYSTEM */
|
|
}
|
|
|
|
|
|
/****************
|
|
* release a lock
|
|
* Returns: 0 := success
|
|
*/
|
|
int
|
|
release_dotlock( DOTLOCK h )
|
|
{
|
|
#ifdef 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\n");
|
|
return -1;
|
|
}
|
|
if( pid != getpid() ) {
|
|
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;
|
|
}
|
|
#else /* __riscos__ */
|
|
if( renamefile(h->lockname, h->tname) ) {
|
|
log_error( "release_dotlock: error renaming lockfile `%s' to `%s'",
|
|
h->lockname, h->tname);
|
|
return -1;
|
|
}
|
|
#endif /* __riscos__ */
|
|
/* fixme: check that the link count is now 1 */
|
|
h->locked = 0;
|
|
return 0;
|
|
#endif /* !HAVE_DOSISH_SYSTEM */
|
|
}
|
|
|
|
|
|
/****************
|
|
* Read the lock file and return the pid, returns -1 on error.
|
|
*/
|
|
static int
|
|
read_lockfile( const char *name )
|
|
{
|
|
#ifdef 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': %s\n", name, strerror(errno) );
|
|
errno = e;
|
|
return -1;
|
|
}
|
|
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 ) {
|
|
#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
|
|
}
|
|
|
|
|
|
void
|
|
dotlock_remove_lockfiles()
|
|
{
|
|
#ifndef 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);
|
|
jnlib_free(h->tname);
|
|
jnlib_free(h->lockname);
|
|
}
|
|
jnlib_free(h);
|
|
h = h2;
|
|
}
|
|
#endif
|
|
}
|
|
|