[git] GnuPG - branch, master, updated. post-nuke-of-trailing-ws-106-gbf3d5be
by Werner Koch
cvs at cvs.gnupg.org
Thu Sep 29 16:13:52 CEST 2011
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "The GNU Privacy Guard".
The branch, master has been updated
via bf3d5beb7103b64905c48a2ec33efbfab39cbce0 (commit)
via ed8e267859a00233fee89a6b1b7fb3d74ceced96 (commit)
from 567a31c2a0c6d5cbf700b4667e1bb91389fd2246 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit bf3d5beb7103b64905c48a2ec33efbfab39cbce0
Author: Werner Koch <wk at gnupg.org>
Date: Thu Sep 29 15:27:01 2011 +0200
Make dotlock.c thread-safe on pthread systems.
This is achieved by passing the define DOTLOCK_USE_PTHREAD.
diff --git a/common/ChangeLog b/common/ChangeLog
index da016bd..7ed2673 100644
--- a/common/ChangeLog
+++ b/common/ChangeLog
@@ -1,3 +1,10 @@
+2011-09-29 Werner Koch <wk at g10code.com>
+
+ * dotlock.c (DOTLOCK_USE_PTHREAD): New macro.
+ [DOTLOCK_USE_PTHREAD] (all_lockfiles_mutex): New.
+ (LOCK_all_lockfiles, UNLOCK_all_lockfiles): New. Use them to
+ protect access to all_lockfiles.
+
2011-09-28 Werner Koch <wk at g10code.com>
* dotlock.c (dotlock_take, dotlock_take_unix, dotlock_take_w32):
diff --git a/common/dotlock.c b/common/dotlock.c
index 37a1df3..1463944 100644
--- a/common/dotlock.c
+++ b/common/dotlock.c
@@ -57,7 +57,8 @@
This installs an atexit handler and may also initialize mutex etc.
It is optional for non-threaded applications. Only the first call
- has an effect.
+ has an effect. This needs to be done before any extra threads are
+ started.
To create a lock file (which prepares it but does not take the
lock) you do:
@@ -71,12 +72,14 @@
It is important to handle the error. For example on a read-only
file system a lock can't be created (but is usually not needed).
FNAME is the file you want to lock; the actual lockfile is that
- name with the suffix ".lock" appended. This call creates a unique
- file temporary file (".#lk*") in the same directory as FNAME and
- returns a handle for further operations. The module keeps track of
- theses unique files so that they will be unlinked using the atexit
- handler. If you don't need the lock file anymore, you may also
- explicitly remove it with a call to:
+ name with the suffix ".lock" appended. On success a handle to be
+ used with the other functions is returned or NULL on error. Note
+ that the handle shall only be used by one thread at a time. This
+ function creates a unique file temporary file (".#lk*") in the same
+ directory as FNAME and returns a handle for further operations.
+ The module keeps track of theses unique files so that they will be
+ unlinked using the atexit handler. If you don't need the lock file
+ anymore, you may also explicitly remove it with a call to:
dotlock_destroy (h);
@@ -124,6 +127,8 @@
to pass -DHAVE_CONFIG_H to the compiler. Macros used by this
module are:
+ DOTLOCK_USE_PTHREAD - Define if POSIX threads are in use.
+
DOTLOCK_GLIB_LOGGING - Define this to use Glib logging functions.
GNUPG_MAJOR_VERSION - Defined when used by GnuPG.
@@ -150,6 +155,12 @@
it on the command line, remember to pass -D_FILE_OFFSET_BITS=64
+ Bugs:
+ =====
+
+ On Windows this module is not yet thread-safe.
+
+
Miscellaneous notes:
====================
@@ -227,6 +238,9 @@
#ifdef HAVE_SIGNAL_H
# include <signal.h>
#endif
+#ifdef DOTLOCK_USE_PTHREAD
+# include <pthread.h>
+#endif
#ifdef DOTLOCK_GLIB_LOGGING
# include <glib.h>
@@ -285,6 +299,7 @@
# define my_error_1(a,b) log_error ((a), (b))
# define my_error_2(a,b,c) log_error ((a), (b), (c))
# define my_debug_1(a,b) log_debug ((a), (b))
+# define my_fatal_0(a) log_fatal ((a))
#elif defined (DOTLOCK_GLIB_LOGGING)
# define my_info_0(a) g_message ((a))
# define my_info_1(a,b) g_message ((a), (b))
@@ -294,6 +309,7 @@
# define my_error_1(a,b) g_warning ((a), (b))
# define my_error_2(a,b,c g_warning ((a), (b), (c))
# define my_debug_1(a,b) g_debug ((a), (b))
+# define my_fatal_0(a) g_error ((a))
#else
# define my_info_0(a) fprintf (stderr, (a))
# define my_info_1(a,b) fprintf (stderr, (a), (b))
@@ -303,6 +319,8 @@
# define my_error_1(a,b) fprintf (stderr, (a), (b))
# define my_error_2(a,b,c) fprintf (stderr, (a), (b), (c))
# define my_debug_1(a,b) fprintf (stderr, (a), (b))
+# define my_fatal_0(a) do { fprintf (stderr,(a)); fflush (stderr); \
+ abort (); } while (0)
#endif
@@ -331,11 +349,27 @@ struct dotlock_handle
/* A list of of all lock handles. The volatile attribute might help
if used in an atexit handler. */
static volatile dotlock_t all_lockfiles;
+#ifdef DOTLOCK_USE_PTHREAD
+static pthread_mutex_t all_lockfiles_mutex = PTHREAD_MUTEX_INITIALIZER;
+# define LOCK_all_lockfiles() do { \
+ if (pthread_mutex_lock (&all_lockfiles_mutex)) \
+ my_fatal_0 ("locking all_lockfiles_mutex failed\n"); \
+ } while (0)
+# define UNLOCK_all_lockfiles() do { \
+ if (pthread_mutex_unlock (&all_lockfiles_mutex)) \
+ my_fatal_0 ("unlocking all_lockfiles_mutex failed\n"); \
+ } while (0)
+#else /*!DOTLOCK_USE_PTHREAD*/
+# define LOCK_all_lockfiles() do { } while (0)
+# define UNLOCK_all_lockfiles() do { } while (0)
+#endif /*!DOTLOCK_USE_PTHREAD*/
/* If this has the value true all locking is disabled. */
static int never_lock;
+
+
/* Entirely disable all locking. This function should be called
before any locking is done. It may be called right at startup of
@@ -352,13 +386,19 @@ static int
maybe_deadlock (dotlock_t h)
{
dotlock_t r;
+ int res = 0;
- for ( r=all_lockfiles; r; r = r->next )
+ LOCK_all_lockfiles ();
+ for (r=all_lockfiles; r; r = r->next)
{
if ( r != h && r->locked )
- return 1;
+ {
+ res = 1;
+ break;
+ }
}
- return 0;
+ UNLOCK_all_lockfiles ();
+ return res;
}
#endif /*HAVE_POSIX_SYSTEM*/
@@ -528,9 +568,7 @@ dotlock_create_unix (dotlock_t h, const char *file_to_lock)
dirpart = file_to_lock;
}
-#ifdef _REENTRANT
- /* fixme: aquire mutex on all_lockfiles */
-#endif
+ LOCK_all_lockfiles ();
h->next = all_lockfiles;
all_lockfiles = h;
@@ -539,6 +577,7 @@ dotlock_create_unix (dotlock_t h, const char *file_to_lock)
if (!h->tname)
{
all_lockfiles = h->next;
+ UNLOCK_all_lockfiles ();
jnlib_free (h);
return NULL;
}
@@ -560,6 +599,7 @@ dotlock_create_unix (dotlock_t h, const char *file_to_lock)
if ( fd == -1 )
{
all_lockfiles = h->next;
+ UNLOCK_all_lockfiles ();
my_error_2 (_("failed to create temporary file `%s': %s\n"),
h->tname, strerror(errno));
jnlib_free (h->tname);
@@ -590,19 +630,18 @@ dotlock_create_unix (dotlock_t h, const char *file_to_lock)
goto write_failed;
}
-# ifdef _REENTRANT
- /* release mutex */
-# endif
h->lockname = jnlib_malloc (strlen (file_to_lock) + 6 );
if (!h->lockname)
{
all_lockfiles = h->next;
+ UNLOCK_all_lockfiles ();
unlink (h->tname);
jnlib_free (h->tname);
jnlib_free (h);
return NULL;
}
strcpy (stpcpy (h->lockname, file_to_lock), EXTSEP_S "lock");
+ UNLOCK_all_lockfiles ();
if (h->use_o_excl)
my_debug_1 ("locking for `%s' done via O_EXCL\n", h->lockname);
@@ -610,9 +649,7 @@ dotlock_create_unix (dotlock_t h, const char *file_to_lock)
write_failed:
all_lockfiles = h->next;
-# ifdef _REENTRANT
- /* fixme: release mutex */
-# endif
+ UNLOCK_all_lockfiles ();
my_error_2 (_("error writing to `%s': %s\n"), h->tname, strerror (errno));
close (fd);
unlink (h->tname);
@@ -632,6 +669,7 @@ dotlock_create_unix (dotlock_t h, const char *file_to_lock)
static dotlock_t
dotlock_create_w32 (dotlock_t h, const char *file_to_lock)
{
+ LOCK_all_lockfiles ();
h->next = all_lockfiles;
all_lockfiles = h;
@@ -639,6 +677,7 @@ dotlock_create_w32 (dotlock_t h, const char *file_to_lock)
if (!h->lockname)
{
all_lockfiles = h->next;
+ UNLOCK_all_lockfiles ();
jnlib_free (h);
return NULL;
}
@@ -673,8 +712,9 @@ dotlock_create_w32 (dotlock_t h, const char *file_to_lock)
}
if (h->lockhd == INVALID_HANDLE_VALUE)
{
- my_error_2 (_("can't create `%s': %s\n"), h->lockname, w32_strerror (-1));
all_lockfiles = h->next;
+ UNLOCK_all_lockfiles ();
+ my_error_2 (_("can't create `%s': %s\n"), h->lockname, w32_strerror (-1));
jnlib_free (h->lockname);
jnlib_free (h);
return NULL;
@@ -733,11 +773,10 @@ dotlock_create (const char *file_to_lock, unsigned int flags)
if (never_lock)
{
h->disable = 1;
-#ifdef _REENTRANT
- /* fixme: aquire mutex on all_lockfiles */
-#endif
+ LOCK_all_lockfiles ();
h->next = all_lockfiles;
all_lockfiles = h;
+ UNLOCK_all_lockfiles ();
return h;
}
@@ -791,6 +830,7 @@ dotlock_destroy (dotlock_t h)
return;
/* First remove the handle from our global list of all locks. */
+ LOCK_all_lockfiles ();
for (hprev=NULL, htmp=all_lockfiles; htmp; hprev=htmp, htmp=htmp->next)
if (htmp == h)
{
@@ -801,6 +841,7 @@ dotlock_destroy (dotlock_t h)
h->next = NULL;
break;
}
+ UNLOCK_all_lockfiles ();
/* Then destroy the lock. */
if (!h->disable)
@@ -1123,7 +1164,10 @@ dotlock_release (dotlock_t h)
any locks left. It might happen that another atexit handler
tries to release the lock while the atexit handler of this module
already ran and thus H is undefined. */
- if (!all_lockfiles)
+ LOCK_all_lockfiles ();
+ ret = !all_lockfiles;
+ UNLOCK_all_lockfiles ();
+ if (ret)
return 0;
if ( h->disable )
@@ -1148,7 +1192,7 @@ dotlock_release (dotlock_t h)
-/* Remove all lockfiles. This is usually called by the atexit handler
+/* Remove all lockfiles. This is called by the atexit handler
installed by this module but may also be called by other
termination handlers. */
void
@@ -1156,8 +1200,13 @@ dotlock_remove_lockfiles (void)
{
dotlock_t h, h2;
+ /* First set the lockfiles list to NULL so that for example
+ dotlock_release is ware that this fucntion is currently
+ running. */
+ LOCK_all_lockfiles ();
h = all_lockfiles;
all_lockfiles = NULL;
+ UNLOCK_all_lockfiles ();
while ( h )
{
commit ed8e267859a00233fee89a6b1b7fb3d74ceced96
Author: Werner Koch <wk at gnupg.org>
Date: Wed Sep 28 15:41:58 2011 +0200
Add a flag parameter to dotlock_create.
This allows us to extend this function in the future.
diff --git a/common/ChangeLog b/common/ChangeLog
index 0f66a41..da016bd 100644
--- a/common/ChangeLog
+++ b/common/ChangeLog
@@ -2,6 +2,7 @@
* dotlock.c (dotlock_take, dotlock_take_unix, dotlock_take_w32):
Implement arbitrary timeout values.
+ (dotlock_create): Add arg FLAGS for future extensions.
2011-09-27 Werner Koch <wk at g10code.com>
diff --git a/common/asshelp.c b/common/asshelp.c
index 96d9a24..c5d8bdf 100644
--- a/common/asshelp.c
+++ b/common/asshelp.c
@@ -287,7 +287,7 @@ lock_spawning (lock_spawn_t *lock, const char *homedir, const char *name,
if (!fname)
return gpg_error_from_syserror ();
- *lock = dotlock_create (fname);
+ *lock = dotlock_create (fname, 0);
xfree (fname);
if (!*lock)
return gpg_error_from_syserror ();
diff --git a/common/dotlock.c b/common/dotlock.c
index e3e9fa3..37a1df3 100644
--- a/common/dotlock.c
+++ b/common/dotlock.c
@@ -53,7 +53,7 @@
At program initialization time, the module should be explicitly
initialized:
- dotlock_create (NULL);
+ dotlock_create (NULL, 0);
This installs an atexit handler and may also initialize mutex etc.
It is optional for non-threaded applications. Only the first call
@@ -64,7 +64,7 @@
dotlock_t h
- h = dotlock_create (fname);
+ h = dotlock_create (fname, 0);
if (!h)
error ("error creating lock file: %s\n", strerror (errno));
@@ -656,17 +656,19 @@ dotlock_create_w32 (dotlock_t h, const char *file_to_lock)
#ifdef HAVE_W32CE_SYSTEM
wchar_t *wname = utf8_to_wchar (h->lockname);
- h->lockhd = INVALID_HANDLE_VALUE;
if (wname)
h->lockhd = CreateFile (wname,
+ GENERIC_READ|GENERIC_WRITE,
+ FILE_SHARE_READ|FILE_SHARE_WRITE,
+ NULL, OPEN_ALWAYS, 0, NULL);
+ else
+ h->lockhd = INVALID_HANDLE_VALUE;
+ jnlib_free (wname);
#else
h->lockhd = CreateFile (h->lockname,
-#endif
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL, OPEN_ALWAYS, 0, NULL);
-#ifdef HAVE_W32CE_SYSTEM
- jnlib_free (wname);
#endif
}
if (h->lockhd == INVALID_HANDLE_VALUE)
@@ -696,12 +698,15 @@ dotlock_create_w32 (dotlock_t h, const char *file_to_lock)
POSIX systems a temporary file ".#lk.<hostname>.pid[.threadid] is
used.
+ FLAGS must be 0.
+
The function returns an new handle which needs to be released using
destroy_dotlock but gets also released at the termination of the
process. On error NULL is returned.
*/
+
dotlock_t
-dotlock_create (const char *file_to_lock)
+dotlock_create (const char *file_to_lock, unsigned int flags)
{
static int initialized;
dotlock_t h;
@@ -715,6 +720,12 @@ dotlock_create (const char *file_to_lock)
if ( !file_to_lock )
return NULL; /* Only initialization was requested. */
+ if (flags)
+ {
+ jnlib_set_errno (EINVAL);
+ return NULL;
+ }
+
h = jnlib_calloc (1, sizeof *h);
if (!h)
return NULL;
diff --git a/common/dotlock.h b/common/dotlock.h
index 5fb7891..666d0b7 100644
--- a/common/dotlock.h
+++ b/common/dotlock.h
@@ -26,8 +26,8 @@ struct dotlock_handle;
typedef struct dotlock_handle *dotlock_t;
void dotlock_disable (void);
-dotlock_t dotlock_create (const char *file_to_lock);
-void dotlock_destroy ( dotlock_t h );
+dotlock_t dotlock_create (const char *file_to_lock, unsigned int flags);
+void dotlock_destroy (dotlock_t h);
int dotlock_take (dotlock_t h, long timeout);
int dotlock_release (dotlock_t h);
void dotlock_remove_lockfiles (void);
diff --git a/common/t-dotlock.c b/common/t-dotlock.c
index a352f6e..f81b952 100644
--- a/common/t-dotlock.c
+++ b/common/t-dotlock.c
@@ -90,7 +90,7 @@ lock_and_unlock (const char *fname)
{
dotlock_t h;
- h = dotlock_create (fname);
+ h = dotlock_create (fname, 0);
if (!h)
die ("error creating lock file for `%s': %s", fname, strerror (errno));
inf ("lock created");
@@ -129,7 +129,7 @@ main (int argc, char **argv)
sigaction (SIGINT, &nact, NULL);
}
- dotlock_create (NULL); /* Initialize (optional). */
+ dotlock_create (NULL, 0); /* Initialize (optional). */
lock_and_unlock (fname);
diff --git a/g10/gpg.c b/g10/gpg.c
index 51661b3..c31a558 100644
--- a/g10/gpg.c
+++ b/g10/gpg.c
@@ -1969,7 +1969,7 @@ main (int argc, char **argv)
gnupg_init_signals (0, emergency_cleanup);
- dotlock_create (NULL); /* Register lock file cleanup. */
+ dotlock_create (NULL, 0); /* Register lock file cleanup. */
opt.session_env = session_env_new ();
if (!opt.session_env)
diff --git a/g10/gpgv.c b/g10/gpgv.c
index 9328343..8ca6752 100644
--- a/g10/gpgv.c
+++ b/g10/gpgv.c
@@ -507,9 +507,10 @@ dotlock_disable (void)
}
dotlock_t
-dotlock_create (const char *file_to_lock)
+dotlock_create (const char *file_to_lock, unsigned int flags)
{
(void)file_to_lock;
+ (void)flags;
return NULL;
}
diff --git a/g10/keydb.c b/g10/keydb.c
index e4b9709..9b9b2ed 100644
--- a/g10/keydb.c
+++ b/g10/keydb.c
@@ -136,7 +136,7 @@ maybe_create_keyring (char *filename, int force)
/* To avoid races with other instances of gpg trying to create or
update the keyring (it is removed during an update for a short
time), we do the next stuff in a locked state. */
- lockhd = dotlock_create (filename);
+ lockhd = dotlock_create (filename, 0);
if (!lockhd)
{
/* A reason for this to fail is that the directory is not
diff --git a/g10/keyring.c b/g10/keyring.c
index 480c0e9..4eb26aa 100644
--- a/g10/keyring.c
+++ b/g10/keyring.c
@@ -306,7 +306,7 @@ keyring_lock (KEYRING_HANDLE hd, int yes)
if (!keyring_is_writable(kr))
continue;
if (!kr->lockhd) {
- kr->lockhd = dotlock_create( kr->fname );
+ kr->lockhd = dotlock_create (kr->fname, 0);
if (!kr->lockhd) {
log_info ("can't allocate lock for `%s'\n", kr->fname );
rc = G10ERR_GENERAL;
diff --git a/g10/tdbio.c b/g10/tdbio.c
index 968d06b..1ab11f2 100644
--- a/g10/tdbio.c
+++ b/g10/tdbio.c
@@ -544,7 +544,7 @@ tdbio_set_dbname( const char *new_dbname, int create )
db_name = fname;
#ifdef __riscos__
if( !lockhandle )
- lockhandle = dotlock_create (db_name);
+ lockhandle = dotlock_create (db_name, 0);
if( !lockhandle )
log_fatal( _("can't create lock for `%s'\n"), db_name );
if( dotlock_make (lockhandle, -1) )
@@ -567,7 +567,7 @@ tdbio_set_dbname( const char *new_dbname, int create )
#ifndef __riscos__
if( !lockhandle )
- lockhandle = dotlock_create (db_name);
+ lockhandle = dotlock_create (db_name, 0);
if( !lockhandle )
log_fatal( _("can't create lock for `%s'\n"), db_name );
#endif /* !__riscos__ */
@@ -608,7 +608,7 @@ open_db()
assert( db_fd == -1 );
if (!lockhandle )
- lockhandle = dotlock_create (db_name);
+ lockhandle = dotlock_create (db_name, 0);
if (!lockhandle )
log_fatal( _("can't create lock for `%s'\n"), db_name );
#ifdef __riscos__
diff --git a/g13/create.c b/g13/create.c
index 60c1d3d..f907ddb 100644
--- a/g13/create.c
+++ b/g13/create.c
@@ -246,7 +246,7 @@ g13_create_container (ctrl_t ctrl, const char *filename, strlist_t keys)
/* Take a lock and proceed with the creation. If there is a lock we
immediately return an error because for creation it does not make
sense to wait. */
- lock = dotlock_create (filename);
+ lock = dotlock_create (filename, 0);
if (!lock)
return gpg_error_from_syserror ();
if (dotlock_take (lock, 0))
diff --git a/g13/g13.c b/g13/g13.c
index 972a7ea..8e5532c 100644
--- a/g13/g13.c
+++ b/g13/g13.c
@@ -383,7 +383,7 @@ main ( int argc, char **argv)
gnupg_init_signals (0, emergency_cleanup);
- dotlock_create (NULL); /* Register locking cleanup. */
+ dotlock_create (NULL, 0); /* Register locking cleanup. */
opt.session_env = session_env_new ();
if (!opt.session_env)
diff --git a/g13/mount.c b/g13/mount.c
index 198fde0..62eeca1 100644
--- a/g13/mount.c
+++ b/g13/mount.c
@@ -273,7 +273,7 @@ g13_mount_container (ctrl_t ctrl, const char *filename, const char *mountpoint)
}
/* Try to take a lock. */
- lock = dotlock_create (filename);
+ lock = dotlock_create (filename, 0);
if (!lock)
{
xfree (mountpoint_buffer);
diff --git a/sm/gpgsm.c b/sm/gpgsm.c
index 87f94e2..dc9f2e0 100644
--- a/sm/gpgsm.c
+++ b/sm/gpgsm.c
@@ -928,7 +928,7 @@ main ( int argc, char **argv)
gnupg_init_signals (0, emergency_cleanup);
- dotlock_create (NULL); /* Register lockfile cleanup. */
+ dotlock_create (NULL, 0); /* Register lockfile cleanup. */
opt.session_env = session_env_new ();
if (!opt.session_env)
diff --git a/sm/keydb.c b/sm/keydb.c
index 9d1a6ef..86301b3 100644
--- a/sm/keydb.c
+++ b/sm/keydb.c
@@ -214,7 +214,7 @@ keydb_add_resource (const char *url, int force, int secret, int *auto_created)
all_resources[used_resources].secret = secret;
all_resources[used_resources].lockhandle
- = dotlock_create (filename);
+ = dotlock_create (filename, 0);
if (!all_resources[used_resources].lockhandle)
log_fatal ( _("can't create lock for `%s'\n"), filename);
-----------------------------------------------------------------------
Summary of changes:
common/ChangeLog | 8 +++
common/asshelp.c | 2 +-
common/dotlock.c | 124 ++++++++++++++++++++++++++++++++++++++-------------
common/dotlock.h | 4 +-
common/t-dotlock.c | 4 +-
g10/gpg.c | 2 +-
g10/gpgv.c | 3 +-
g10/keydb.c | 2 +-
g10/keyring.c | 2 +-
g10/tdbio.c | 6 +-
g13/create.c | 2 +-
g13/g13.c | 2 +-
g13/mount.c | 2 +-
sm/gpgsm.c | 2 +-
sm/keydb.c | 2 +-
15 files changed, 118 insertions(+), 49 deletions(-)
hooks/post-receive
--
The GNU Privacy Guard
http://git.gnupg.org
More information about the Gnupg-commits
mailing list