Fixed a bunch of little bugs as reported by Fabian Keil.
[gnupg.git] / g10 / keyring.c
index b084aa8..6b3c489 100644 (file)
@@ -1,11 +1,11 @@
 /* keyring.c - keyring file handling
- * Copyright (C) 2001 Free Software Foundation, Inc.
+ * Copyright (C) 2001, 2004, 2009 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
+ * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
@@ -14,8 +14,7 @@
  * 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
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
@@ -28,6 +27,7 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 
+#include "gpg.h"
 #include "util.h"
 #include "keyring.h"
 #include "packet.h"
@@ -50,9 +50,11 @@ typedef struct off_item **OffsetHashTable;
 
 
 typedef struct keyring_name *KR_NAME;
-struct keyring_name {
+struct keyring_name 
+{
   struct keyring_name *next;
   int secret;
+  int readonly;
   DOTLOCK lockhd;
   int is_locked;
   int did_full_scan;
@@ -101,7 +103,7 @@ new_offset_item (void)
 {
   struct off_item *k;
   
-  k = m_alloc_clear (sizeof *k);
+  k = xmalloc_clear (sizeof *k);
   return k;
 }
 
@@ -114,7 +116,7 @@ release_offset_items (struct off_item *k)
   for (; k; k = k2)
     {
       k2 = k->next;
-      m_free (k);
+      xfree (k);
     }
 }
 #endif
@@ -124,7 +126,7 @@ new_offset_hash_table (void)
 {
   struct off_item **tbl;
 
-  tbl = m_alloc_clear (2048 * sizeof *tbl);
+  tbl = xmalloc_clear (2048 * sizeof *tbl);
   return tbl;
 }
 
@@ -138,7 +140,7 @@ release_offset_hash_table (OffsetHashTable tbl)
     return;
   for (i=0; i < 2048; i++)
     release_offset_items (tbl[i]);
-  m_free (tbl);
+  xfree (tbl);
 }
 #endif
 
@@ -158,6 +160,8 @@ update_offset_hash_table (OffsetHashTable tbl, u32 *kid, off_t off)
 {
   struct off_item *k;
 
+  (void)off;
+
   for (k = tbl[(kid[1] & 0x07ff)]; k; k = k->next)
     {
       if (k->kid[0] == kid[0] && k->kid[1] == kid[1]) 
@@ -190,29 +194,40 @@ update_offset_hash_table_from_kb (OffsetHashTable tbl, KBNODE node, off_t off)
     }
 }
 
-
-
-\f
 /* 
- * Register a filename for plain keyring files.  Returns a pointer to
- * be used to create a handles etc or NULL to indicate that it has
- * already been registered */
-void *
-keyring_register_filename (const char *fname, int secret)
+ * Register a filename for plain keyring files.  ptr is set to a
+ * pointer to be used to create a handles etc, or the already-issued
+ * pointer if it has already been registered.  The function returns 1
+ * if a new keyring was registered.
+*/
+int
+keyring_register_filename (const char *fname, int secret, int readonly, 
+                           void **ptr)
 {
     KR_NAME kr;
 
     if (active_handles)
         BUG (); /* We don't allow that */
 
-    for (kr=kr_names; kr; kr = kr->next) {
-        if ( !compare_filenames (kr->fname, fname) )
-            return NULL; /* already registered */
-    }
+    for (kr=kr_names; kr; kr = kr->next)
+      {
+        if (same_file_p (kr->fname, fname))
+         {
+            /* Already registered. */
+            if (readonly)
+              kr->readonly = 1;
+            *ptr=kr;
+           return 0; 
+         }
+      }
 
-    kr = m_alloc (sizeof *kr + strlen (fname));
+    if (secret)
+      register_secured_file (fname);
+
+    kr = xmalloc (sizeof *kr + strlen (fname));
     strcpy (kr->fname, fname);
     kr->secret = !!secret;
+    kr->readonly = readonly;
     kr->lockhd = NULL;
     kr->is_locked = 0;
     kr->did_full_scan = 0;
@@ -224,7 +239,9 @@ keyring_register_filename (const char *fname, int secret)
     if (!kr_offtbl)
       kr_offtbl = new_offset_hash_table ();
 
-    return kr;
+    *ptr=kr;
+
+    return 1;
 }
 
 int
@@ -232,7 +249,7 @@ keyring_is_writable (void *token)
 {
   KR_NAME r = token;
 
-  return r? !access (r->fname, W_OK) : 0;
+  return r? (r->readonly || !access (r->fname, W_OK)) : 0;
 }
     
 
@@ -249,7 +266,7 @@ keyring_new (void *token, int secret)
 
   assert (resource && !resource->secret == !secret);
   
-  hd = m_alloc_clear (sizeof *hd);
+  hd = xmalloc_clear (sizeof *hd);
   hd->resource = resource;
   hd->secret = !!secret;
   active_handles++;
@@ -263,10 +280,10 @@ keyring_release (KEYRING_HANDLE hd)
         return;
     assert (active_handles > 0);
     active_handles--;
-    m_free (hd->word_match.name);
-    m_free (hd->word_match.pattern);
+    xfree (hd->word_match.name);
+    xfree (hd->word_match.pattern);
     iobuf_close (hd->current.iobuf);
-    m_free (hd);
+    xfree (hd);
 }
 
 
@@ -280,7 +297,7 @@ keyring_get_resource_name (KEYRING_HANDLE hd)
 
 
 /*
- * Lock the keyring with the given handle, or unlok if yes is false.
+ * Lock the keyring with the given handle, or unlock if YES is false.
  * We ignore the handle and lock all registered files.
  */
 int 
@@ -289,6 +306,8 @@ keyring_lock (KEYRING_HANDLE hd, int yes)
     KR_NAME kr;
     int rc = 0;
 
+    (void)hd;
+
     if (yes) {
         /* first make sure the lock handles are created */
         for (kr=kr_names; kr; kr = kr->next) {
@@ -363,10 +382,11 @@ keyring_get_keyblock (KEYRING_HANDLE hd, KBNODE *ret_kb)
         return -1; /* no successful search */
 
     a = iobuf_open (hd->found.kr->fname);
-    if (!a) {
-       log_error ("can't open `%s'\n", hd->found.kr->fname);
+    if (!a)
+      {
+       log_error(_("can't open `%s'\n"), hd->found.kr->fname);
        return G10ERR_KEYRING_OPEN;
-    }
+      }
 
     if (iobuf_seek (a, hd->found.offset) ) {
         log_error ("can't seek `%s'\n", hd->found.kr->fname);
@@ -374,7 +394,7 @@ keyring_get_keyblock (KEYRING_HANDLE hd, KBNODE *ret_kb)
        return G10ERR_KEYRING_OPEN;
     }
 
-    pkt = m_alloc (sizeof *pkt);
+    pkt = xmalloc (sizeof *pkt);
     init_packet (pkt);
     hd->found.n_packets = 0;;
     lastnode = NULL;
@@ -406,44 +426,54 @@ keyring_get_keyblock (KEYRING_HANDLE hd, KBNODE *ret_kb)
         }
 
         in_cert = 1;
-        if (pkt->pkttype == PKT_RING_TRUST) {
+        if (pkt->pkttype == PKT_RING_TRUST) 
+          {
             /*(this code is duplicated after the loop)*/
             if ( lastnode 
                  && lastnode->pkt->pkttype == PKT_SIGNATURE
                  && (pkt->pkt.ring_trust->sigcache & 1) ) {
-                /* this is a ring trust packet with a checked signature 
+                /* This is a ring trust packet with a checked signature 
                  * status cache following directly a signature paket.
-                 * Set the cache status into that signature packet */
+                 * Set the cache status into that signature packet */
                 PKT_signature *sig = lastnode->pkt->pkt.signature;
                 
                 sig->flags.checked = 1;
                 sig->flags.valid = !!(pkt->pkt.ring_trust->sigcache & 2);
             }
-            /* reset lastnode, so that we set the cache status only from
-             * the ring trust packet immediately folling a signature */
+            /* Reset LASTNODE, so that we set the cache status only from
+             * the ring trust packet immediately following a signature. */
             lastnode = NULL;
-        }
-        else {
-            node = lastnode = new_kbnode (pkt);
-            if (!keyblock)
-                keyblock = node;
-            else
-                add_kbnode (keyblock, node);
-
-            if ( pkt->pkttype == PKT_PUBLIC_KEY
-                 || pkt->pkttype == PKT_PUBLIC_SUBKEY
-                 || pkt->pkttype == PKT_SECRET_KEY
-                 || pkt->pkttype == PKT_SECRET_SUBKEY) {
-                if (++pk_no == hd->found.pk_no)
-                    node->flag |= 1;
-            }
-            else if ( pkt->pkttype == PKT_USER_ID) {
-                if (++uid_no == hd->found.uid_no)
-                    node->flag |= 2;
-            }
-        }
+           free_packet(pkt);
+           init_packet(pkt);
+           continue;
+          }
+
+
+        node = lastnode = new_kbnode (pkt);
+        if (!keyblock)
+          keyblock = node;
+        else
+          add_kbnode (keyblock, node);
+        switch (pkt->pkttype)
+          {
+          case PKT_PUBLIC_KEY:
+          case PKT_PUBLIC_SUBKEY:
+          case PKT_SECRET_KEY:
+          case PKT_SECRET_SUBKEY:
+            if (++pk_no == hd->found.pk_no)
+              node->flag |= 1;
+            break;
+
+          case PKT_USER_ID:
+            if (++uid_no == hd->found.uid_no)
+              node->flag |= 2;
+            break;
+            
+          default:
+            break;
+          }
 
-        pkt = m_alloc (sizeof *pkt);
+        pkt = xmalloc (sizeof *pkt);
         init_packet(pkt);
     }
     set_packet_list_mode(save_mode);
@@ -466,7 +496,7 @@ keyring_get_keyblock (KEYRING_HANDLE hd, KBNODE *ret_kb)
        *ret_kb = keyblock;
     }
     free_packet (pkt);
-    m_free (pkt);
+    xfree (pkt);
     iobuf_close(a);
 
     /* Make sure that future search operations fail immediately when
@@ -486,6 +516,9 @@ keyring_update_keyblock (KEYRING_HANDLE hd, KBNODE kb)
     if (!hd->found.kr)
         return -1; /* no successful prior search */
 
+    if (hd->found.kr->readonly)
+      return gpg_error (GPG_ERR_EACCES);
+
     if (!hd->found.n_packets) {
         /* need to know the number of packets - do a dummy get_keyblock*/
         rc = keyring_get_keyblock (hd, NULL);
@@ -527,16 +560,24 @@ keyring_insert_keyblock (KEYRING_HANDLE hd, KBNODE kb)
     if (!hd)
         fname = NULL;
     else if (hd->found.kr)
+      {
         fname = hd->found.kr->fname;
+        if (hd->found.kr->readonly)
+          return gpg_error (GPG_ERR_EACCES);
+      }
     else if (hd->current.kr)
+      {
         fname = hd->current.kr->fname;
+        if (hd->current.kr->readonly)
+          return gpg_error (GPG_ERR_EACCES);
+      }
     else 
         fname = hd->resource? hd->resource->fname:NULL;
 
     if (!fname)
         return G10ERR_GENERAL; 
 
-    /* close this one otherwise we will lose the position for
+    /* Close this one otherwise we will lose the position for
      * a next search.  Fixme: it would be better to adjust the position
      * after the write opertions.
      */
@@ -562,6 +603,9 @@ keyring_delete_keyblock (KEYRING_HANDLE hd)
     if (!hd->found.kr)
         return -1; /* no successful prior search */
 
+    if (hd->found.kr->readonly)
+      return gpg_error (GPG_ERR_EACCES);
+
     if (!hd->found.n_packets) {
         /* need to know the number of packets - do a dummy get_keyblock*/
         rc = keyring_get_keyblock (hd, NULL);
@@ -648,10 +692,12 @@ prepare_search (KEYRING_HANDLE hd)
 
     hd->current.eof = 0;
     hd->current.iobuf = iobuf_open (hd->current.kr->fname);
-    if (!hd->current.iobuf) {
-        log_error ("can't open `%s'\n", hd->current.kr->fname );
-        return (hd->current.error = G10ERR_OPEN_FILE);
-    }
+    if (!hd->current.iobuf)
+      {
+        hd->current.error = gpg_error_from_syserror ();
+        log_error(_("can't open `%s'\n"), hd->current.kr->fname );
+        return hd->current.error;
+      }
 
     return 0;
 }
@@ -769,7 +815,7 @@ prepare_word_match (const byte *name)
     int c;
 
     /* the original length is always enough for the pattern */
-    p = pattern = m_alloc(strlen(name)+1);
+    p = pattern = xmalloc(strlen(name)+1);
     do {
        /* skip leading delimiters */
        while( *name && !word_match_chars[*name] )
@@ -847,7 +893,8 @@ compare_name (int mode, const char *name, const char *uid, size_t uidlen)
  * for a keyblock which contains one of the keys described in the DESC array.
  */
 int 
-keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc, size_t ndesc)
+keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc,
+               size_t ndesc, size_t *descindex)
 {
   int rc;
   PACKET pkt;
@@ -861,6 +908,7 @@ keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc, size_t ndesc)
   PKT_user_id *uid = NULL;
   PKT_public_key *pk = NULL;
   PKT_secret_key *sk = NULL;
+  u32 aki[2];
 
   /* figure out what information we need */
   need_uid = need_words = need_keyid = need_fpr = any_skip = 0;
@@ -944,12 +992,12 @@ keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc, size_t ndesc)
       if ( !hd->word_match.name || strcmp (hd->word_match.name, name) ) 
         {
           /* name changed */
-          m_free (hd->word_match.name);
-          m_free (hd->word_match.pattern);
-          hd->word_match.name = m_strdup (name);
+          xfree (hd->word_match.name);
+          xfree (hd->word_match.pattern);
+          hd->word_match.name = xstrdup (name);
           hd->word_match.pattern = prepare_word_match (name);
         }
-      name = hd->word_match.pattern;
+      /*  name = hd->word_match.pattern; */
     }
 
   init_packet(&pkt);
@@ -963,7 +1011,6 @@ keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc, size_t ndesc)
     {
       byte afp[MAX_FINGERPRINT_LEN];
       size_t an;
-      u32 aki[2];
 
       if (pkt.pkttype == PKT_PUBLIC_KEY  || pkt.pkttype == PKT_SECRET_KEY) 
         {
@@ -1069,11 +1116,15 @@ keyring_search (KEYRING_HANDLE hd, KEYDB_SEARCH_DESC *desc, size_t ndesc)
        }
       free_packet (&pkt);
       continue;
-    found:  
+    found:
+      /* Record which desc we matched on.  Note this value is only
+        meaningful if this function returns with no errors. */
+      if(descindex)
+       *descindex=n;
       for (n=any_skip?0:ndesc; n < ndesc; n++) 
         {
           if (desc[n].skipfnc
-              && desc[n].skipfnc (desc[n].skipfncvalue, aki))
+              && desc[n].skipfnc (desc[n].skipfncvalue, aki, uid))
             break;
         }
       if (n == ndesc)
@@ -1146,40 +1197,48 @@ create_tmp_file (const char *template,
   if (strlen (template) > 4
       && !strcmp (template+strlen(template)-4, EXTSEP_S "gpg") )
     {
-      bakfname = m_alloc (strlen (template) + 1);
+      bakfname = xmalloc (strlen (template) + 1);
       strcpy (bakfname, template);
       strcpy (bakfname+strlen(template)-4, EXTSEP_S "bak");
 
-      tmpfname = m_alloc (strlen( template ) + 1 );
+      tmpfname = xmalloc (strlen( template ) + 1 );
       strcpy (tmpfname,template);
       strcpy (tmpfname+strlen(template)-4, EXTSEP_S "tmp");
     }
     else 
       { /* file does not end with gpg; hmmm */
-       bakfname = m_alloc (strlen( template ) + 5);
+       bakfname = xmalloc (strlen( template ) + 5);
        strcpy (stpcpy(bakfname, template), EXTSEP_S "bak");
 
-       tmpfname = m_alloc (strlen( template ) + 5);
+       tmpfname = xmalloc (strlen( template ) + 5);
        strcpy (stpcpy(tmpfname, template), EXTSEP_S "tmp");
     }
 # else /* Posix file names */
-    bakfname = m_alloc (strlen( template ) + 2);
+    bakfname = xmalloc (strlen( template ) + 2);
     strcpy (stpcpy (bakfname,template),"~");
 
-    tmpfname = m_alloc (strlen( template ) + 5);
+    tmpfname = xmalloc (strlen( template ) + 5);
     strcpy (stpcpy(tmpfname,template), EXTSEP_S "tmp");
 # endif /* Posix filename */
 
     /* Create the temp file with limited access */
     oldmask=umask(077);
-    *r_fp = iobuf_create (tmpfname);
+    if (is_secured_filename (tmpfname))
+      {
+        *r_fp = NULL;
+        errno = EPERM;
+      }
+    else
+      *r_fp = iobuf_create (tmpfname);
     umask(oldmask);
-    if (!*r_fp) {
-       log_error ("can't create `%s': %s\n", tmpfname, strerror(errno) );
-        m_free (tmpfname);
-        m_free (bakfname);
-       return G10ERR_OPEN_FILE;
-    }
+    if (!*r_fp)
+      {
+        int rc = gpg_error_from_syserror ();
+       log_error(_("can't create `%s': %s\n"), tmpfname, strerror(errno) );
+        xfree (tmpfname);
+        xfree (bakfname);
+       return rc;
+      }
     
     *r_bakfname = bakfname;
     *r_tmpfname = tmpfname;
@@ -1191,10 +1250,23 @@ static int
 rename_tmp_file (const char *bakfname, const char *tmpfname,
                  const char *fname, int secret )
 {
-  int rc=0;
+  int rc = 0;
+
+  /* It's a secret keyring, so let's force a fsync just to be safe on
+     filesystems that may not sync data and metadata together
+     (e.g. ext4). */
+  if (secret && iobuf_ioctl (NULL, 4, 0, (char*)tmpfname))
+    {
+      rc = gpg_error_from_syserror ();
+      goto fail;
+    }
 
-  /* invalidate close caches*/
-  iobuf_ioctl (NULL, 2, 0, (char*)tmpfname );
+  /* Invalidate close caches.  */
+  if (iobuf_ioctl (NULL, 2, 0, (char*)tmpfname ))
+    {
+      rc = gpg_error_from_syserror ();
+      goto fail;
+    }
   iobuf_ioctl (NULL, 2, 0, (char*)bakfname );
   iobuf_ioctl (NULL, 2, 0, (char*)fname );
 
@@ -1206,9 +1278,10 @@ rename_tmp_file (const char *bakfname, const char *tmpfname,
 #endif
       if (rename (fname, bakfname) )
         {
+          rc = gpg_error_from_syserror ();
           log_error ("renaming `%s' to `%s' failed: %s\n",
                      fname, bakfname, strerror(errno) );
-          return G10ERR_RENAME_FILE;
+          return rc;
        }
     }
   
@@ -1216,20 +1289,15 @@ rename_tmp_file (const char *bakfname, const char *tmpfname,
 #if defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
   remove( fname );
 #endif
+  if (secret)
+    unregister_secured_file (fname);
   if (rename (tmpfname, fname) )
     {
-      log_error ("renaming `%s' to `%s' failed: %s\n",
+      rc = gpg_error_from_syserror ();
+      log_error (_("renaming `%s' to `%s' failed: %s\n"),
                  tmpfname, fname, strerror(errno) );
-      rc = G10ERR_RENAME_FILE;
-      if (secret)
-        {
-          log_info(_("WARNING: 2 files with confidential"
-                     " information exists.\n"));
-          log_info(_("%s is the unchanged one\n"), fname );
-          log_info(_("%s is the new one\n"), tmpfname );
-          log_info(_("Please fix this possible security flaw\n"));
-       }
-      return rc;
+      register_secured_file (fname);
+      goto fail;
     }
 
   /* Now make sure the file has the same permissions as the original */
@@ -1240,17 +1308,27 @@ rename_tmp_file (const char *bakfname, const char *tmpfname,
 
     statbuf.st_mode=S_IRUSR | S_IWUSR;
 
-    if(((secret && !opt.preserve_permissions) ||
-       (stat(bakfname,&statbuf)==0)) &&
-       (chmod(fname,statbuf.st_mode)==0))
+    if (((secret && !opt.preserve_permissions)
+         || !stat (bakfname,&statbuf)) 
+        && !chmod (fname,statbuf.st_mode))
       ;
     else
-      log_error("WARNING: unable to restore permissions to `%s': %s",
-               fname,strerror(errno));
+      log_error ("WARNING: unable to restore permissions to `%s': %s",
+                 fname, strerror(errno));
   }
 #endif
 
   return 0;
+
+ fail:
+  if (secret)
+    {
+      log_info(_("WARNING: 2 files with confidential information exists.\n"));
+      log_info(_("%s is the unchanged one\n"), fname );
+      log_info(_("%s is the new one\n"), tmpfname );
+      log_info(_("Please fix this possible security flaw\n"));
+    }
+  return rc;
 }
 
 
@@ -1285,10 +1363,12 @@ write_keyblock (IOBUF fp, KBNODE keyblock)
           iobuf_put (fp, 0xb0); /* old style packet 12, 1 byte len*/
           iobuf_put (fp, 2);    /* 2 bytes */
           iobuf_put (fp, 0);    /* unused */
-          if (iobuf_put (fp, cacheval)) {
-            log_error ("writing sigcache packet failed\n");
-            return G10ERR_WRITE_FILE;
-          }
+          if (iobuf_put (fp, cacheval)) 
+            {
+              rc = gpg_error_from_syserror ();
+              log_error ("writing sigcache packet failed\n");
+              return rc;
+            }
         }
     }
   return 0;
@@ -1300,7 +1380,7 @@ write_keyblock (IOBUF fp, KBNODE keyblock)
  * This is only done for the public keyrings.
  */
 int
-keyring_rebuild_cache (void *token)
+keyring_rebuild_cache (void *token,int noisy)
 {
   KEYRING_HANDLE hd;
   KEYDB_SEARCH_DESC desc;
@@ -1316,7 +1396,11 @@ keyring_rebuild_cache (void *token)
   memset (&desc, 0, sizeof desc);
   desc.mode = KEYDB_SEARCH_MODE_FIRST;
 
-  while ( !(rc = keyring_search (hd, &desc, 1)) )
+  rc=keyring_lock (hd, 1);
+  if(rc)
+    goto leave;
+
+  while ( !(rc = keyring_search (hd, &desc, 1, NULL)) )
     {
       desc.mode = KEYDB_SEARCH_MODE_NEXT;
       resname = keyring_get_resource_name (hd);
@@ -1326,9 +1410,9 @@ keyring_rebuild_cache (void *token)
             {
               if (iobuf_close (tmpfp))
                 {
+                  rc = gpg_error_from_syserror ();
                   log_error ("error closing `%s': %s\n",
                              tmpfilename, strerror (errno));
-                  rc = G10ERR_CLOSE_FILE;
                   goto leave;
                 }
               /* because we have switched resources, we can be sure that
@@ -1337,13 +1421,13 @@ keyring_rebuild_cache (void *token)
             }
           rc = lastresname? rename_tmp_file (bakfilename, tmpfilename, 
                                              lastresname, 0) : 0;
-          m_free (tmpfilename);  tmpfilename = NULL;
-          m_free (bakfilename);  bakfilename = NULL;
+          xfree (tmpfilename);  tmpfilename = NULL;
+          xfree (bakfilename);  bakfilename = NULL;
           if (rc)
             goto leave;
           lastresname = resname;
-          if (!opt.quiet)
-            log_info (_("checking keyring `%s'\n"), resname);
+          if (noisy && !opt.quiet)
+            log_info (_("caching keyring `%s'\n"), resname);
           rc = create_tmp_file (resname, &bakfilename, &tmpfilename, &tmpfp);
           if (rc)
             goto leave;
@@ -1361,9 +1445,24 @@ keyring_rebuild_cache (void *token)
       /* check all signature to set the signature's cache flags */
       for (node=keyblock; node; node=node->next)
         {
+         /* Note that this doesn't cache the result of a revocation
+            issued by a designated revoker.  This is because the pk
+            in question does not carry the revkeys as we haven't
+            merged the key and selfsigs.  It is questionable whether
+            this matters very much since there are very very few
+            designated revoker revocation packets out there. */
+
           if (node->pkt->pkttype == PKT_SIGNATURE)
             {
-              check_key_signature (keyblock, node, NULL);
+             PKT_signature *sig=node->pkt->pkt.signature;
+
+             if(!opt.no_sig_cache && sig->flags.checked && sig->flags.valid
+                && (openpgp_md_test_algo(sig->digest_algo)
+                    || openpgp_pk_test_algo(sig->pubkey_algo)))
+               sig->flags.checked=sig->flags.valid=0;
+             else
+               check_key_signature (keyblock, node, NULL);
+
               sigcount++;
             }
         }
@@ -1373,8 +1472,8 @@ keyring_rebuild_cache (void *token)
       if (rc)
         goto leave;
 
-      if ( !(++count % 50) && !opt.quiet)
-        log_info(_("%lu keys so far checked (%lu signatures)\n"),
+      if ( !(++count % 50) && noisy && !opt.quiet)
+        log_info(_("%lu keys cached so far (%lu signatures)\n"),
                  count, sigcount );
 
     } /* end main loop */ 
@@ -1385,14 +1484,15 @@ keyring_rebuild_cache (void *token)
       log_error ("keyring_search failed: %s\n", g10_errstr(rc));
       goto leave;
     }
-  log_info(_("%lu keys checked (%lu signatures)\n"), count, sigcount );
+  if(noisy || opt.verbose)
+    log_info(_("%lu keys cached (%lu signatures)\n"), count, sigcount );
   if (tmpfp)
     {
       if (iobuf_close (tmpfp))
         {
+          rc = gpg_error_from_syserror ();
           log_error ("error closing `%s': %s\n",
                      tmpfilename, strerror (errno));
-          rc = G10ERR_CLOSE_FILE;
           goto leave;
         }
       /* because we have switched resources, we can be sure that
@@ -1401,15 +1501,16 @@ keyring_rebuild_cache (void *token)
     }
   rc = lastresname? rename_tmp_file (bakfilename, tmpfilename,
                                      lastresname, 0) : 0;
-  m_free (tmpfilename);  tmpfilename = NULL;
-  m_free (bakfilename);  bakfilename = NULL;
+  xfree (tmpfilename);  tmpfilename = NULL;
+  xfree (bakfilename);  bakfilename = NULL;
 
  leave:
   if (tmpfp)
     iobuf_cancel (tmpfp);
-  m_free (tmpfilename);  
-  m_free (bakfilename);  
+  xfree (tmpfilename);  
+  xfree (bakfilename);  
   release_kbnode (keyblock);
+  keyring_lock (hd, 0);
   keyring_release (hd);
   return rc;
 }
@@ -1430,10 +1531,10 @@ do_copy (int mode, const char *fname, KBNODE root, int secret,
     char *bakfname = NULL;
     char *tmpfname = NULL;
 
-    /* Open the source file. Because we do a rname, we have to check the 
+    /* Open the source file. Because we do a rename, we have to check the 
        permissions of the file */
     if (access (fname, W_OK))
-      return G10ERR_WRITE_FILE;
+      return gpg_error_from_syserror ();
 
     fp = iobuf_open (fname);
     if (mode == 1 && !fp && errno == ENOENT) { 
@@ -1442,13 +1543,19 @@ do_copy (int mode, const char *fname, KBNODE root, int secret,
        mode_t oldmask;
 
        oldmask=umask(077);
-       newfp = iobuf_create (fname);
+        if (!secret && is_secured_filename (fname)) {
+            newfp = NULL;
+            errno = EPERM;
+        }
+        else
+            newfp = iobuf_create (fname);
        umask(oldmask);
-       if( !newfp ) {
-           log_error (_("%s: can't create: %s\n"),
-                       fname, strerror(errno));
-           return G10ERR_OPEN_FILE;
-       }
+       if( !newfp )
+         {
+            rc = gpg_error_from_syserror ();
+           log_error (_("can't create `%s': %s\n"), fname, strerror(errno));
+           return rc;
+         }
        if( !opt.quiet )
            log_info(_("%s: keyring created\n"), fname );
 
@@ -1458,28 +1565,33 @@ do_copy (int mode, const char *fname, KBNODE root, int secret,
                log_error("build_packet(%d) failed: %s\n",
                            node->pkt->pkttype, g10_errstr(rc) );
                iobuf_cancel(newfp);
-               return G10ERR_WRITE_FILE;
+               return rc;
            }
        }
        if( iobuf_close(newfp) ) {
+            rc = gpg_error_from_syserror ();
            log_error ("%s: close failed: %s\n", fname, strerror(errno));
-           return G10ERR_CLOSE_FILE;
+           return rc;
        }
        return 0; /* ready */
     }
 
-    if( !fp ) {
-       log_error ("%s: can't open: %s\n", fname, strerror(errno) );
-       rc = G10ERR_OPEN_FILE;
+    if( !fp )
+      {
+        rc = gpg_error_from_syserror ();
+       log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
        goto leave;
-    }
+      }
 
-    /* create the new file */
+    /* Create the new file.  */
     rc = create_tmp_file (fname, &bakfname, &tmpfname, &newfp);
     if (rc) {
        iobuf_close(fp);
        goto leave;
     }
+    if (secret)
+      register_secured_file (tmpfname);
+
     if( mode == 1 ) { /* insert */
        /* copy everything to the new file */
        rc = copy_all_packets (fp, newfp);
@@ -1487,6 +1599,8 @@ do_copy (int mode, const char *fname, KBNODE root, int secret,
            log_error("%s: copy to `%s' failed: %s\n",
                      fname, tmpfname, g10_errstr(rc) );
            iobuf_close(fp);
+            if (secret)
+              unregister_secured_file (tmpfname);
            iobuf_cancel(newfp);
            goto leave;
        }
@@ -1500,6 +1614,8 @@ do_copy (int mode, const char *fname, KBNODE root, int secret,
            log_error ("%s: copy to `%s' failed: %s\n",
                        fname, tmpfname, g10_errstr(rc) );
            iobuf_close(fp);
+            if (secret)
+              unregister_secured_file (tmpfname);
            iobuf_cancel(newfp);
            goto leave;
        }
@@ -1510,6 +1626,8 @@ do_copy (int mode, const char *fname, KBNODE root, int secret,
            log_error("%s: skipping %u packets failed: %s\n",
                            fname, n_packets, g10_errstr(rc));
            iobuf_close(fp);
+            if (secret)
+              unregister_secured_file (tmpfname);
            iobuf_cancel(newfp);
            goto leave;
        }
@@ -1519,6 +1637,8 @@ do_copy (int mode, const char *fname, KBNODE root, int secret,
         rc = write_keyblock (newfp, root);
         if (rc) {
           iobuf_close(fp);
+          if (secret)
+            unregister_secured_file (tmpfname);
           iobuf_cancel(newfp);
           goto leave;
         }
@@ -1531,6 +1651,8 @@ do_copy (int mode, const char *fname, KBNODE root, int secret,
            log_error("%s: copy to `%s' failed: %s\n",
                      fname, tmpfname, g10_errstr(rc) );
            iobuf_close(fp);
+            if (secret)
+              unregister_secured_file (tmpfname);
            iobuf_cancel(newfp);
            goto leave;
        }
@@ -1539,20 +1661,20 @@ do_copy (int mode, const char *fname, KBNODE root, int secret,
 
     /* close both files */
     if( iobuf_close(fp) ) {
+        rc = gpg_error_from_syserror ();
        log_error("%s: close failed: %s\n", fname, strerror(errno) );
-       rc = G10ERR_CLOSE_FILE;
        goto leave;
     }
     if( iobuf_close(newfp) ) {
+        rc = gpg_error_from_syserror ();
        log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
-       rc = G10ERR_CLOSE_FILE;
        goto leave;
     }
 
     rc = rename_tmp_file (bakfname, tmpfname, fname, secret);
 
   leave:
-    m_free(bakfname);
-    m_free(tmpfname);
+    xfree(bakfname);
+    xfree(tmpfname);
     return rc;
 }