edit-key is now complete
[gnupg.git] / g10 / ringedit.c
index 8b74319..58eb6d6 100644 (file)
@@ -1,14 +1,14 @@
 /* ringedit.c -  Function for key ring editing
- *     Copyright (c) 1997 by Werner Koch (dd9jn)
+ *     Copyright (C) 1998 Free Software Foundation, Inc.
  *
- * This file is part of G10.
+ * This file is part of GNUPG.
  *
- * G10 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.
  *
- * G10 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.
@@ -35,7 +35,6 @@
  *
  *  - Delete a key block
  *
- * FIXME:  Add backup stuff
  * FIXME:  Keep track of all nodes, so that a change is propagated
  *        to all nodes. (or use shallow copies and ref-counting?)
  */
@@ -46,6 +45,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
 #include <assert.h>
 #include "util.h"
 #include "packet.h"
@@ -67,11 +69,14 @@ typedef struct resource_table_struct RESTBL;
 #define MAX_RESOURCES 10
 static RESTBL resource_table[MAX_RESOURCES];
 
+static int search( PACKET *pkt, KBPOS *kbpos, int secret );
 
-static int keyring_search( PACKET *pkt, KBPOS *kbpos, IOBUF iobuf );
+
+static int keyring_search( PACKET *pkt, KBPOS *kbpos, IOBUF iobuf,
+                                               const char *fname );
 static int keyring_read( KBPOS *kbpos, KBNODE *ret_root );
-static int keyring_insert( KBPOS *kbpos, KBNODE root );
-static int keyring_delete( KBPOS *kbpos );
+static int keyring_enum( KBPOS *kbpos, KBNODE *ret_root, int skipsigs );
+static int keyring_copy( KBPOS *kbpos, int mode, KBNODE root );
 
 
 
@@ -86,13 +91,12 @@ check_pos( KBPOS *kbpos )
 }
 
 
-
 /****************************************************************
  ****************** public functions ****************************
  ****************************************************************/
 
 /****************
- * Register a resource (which currently may ionly be a keyring file).
+ * Register a resource (which currently may only be a keyring file).
  */
 int
 add_keyblock_resource( const char *filename, int force, int secret )
@@ -106,9 +110,24 @@ add_keyblock_resource( const char *filename, int force, int secret )
     if( i == MAX_RESOURCES )
        return G10ERR_RESOURCE_LIMIT;
 
+  #if __MINGW32__
+    iobuf = NULL;
+  #else
     iobuf = iobuf_open( filename );
     if( !iobuf && !force )
        return G10ERR_OPEN_FILE;
+  #endif
+
+    if( !iobuf ) {
+       iobuf = iobuf_create( filename );
+       if( !iobuf ) {
+           log_error("%s: can't create: %s\n", filename, strerror(errno));
+           return G10ERR_OPEN_FILE;
+       }
+       else
+           log_info("%s: keyring created\n", filename );
+    }
+
     resource_table[i].used = 1;
     resource_table[i].secret = !!secret;
     resource_table[i].fname = m_strdup(filename);
@@ -116,10 +135,24 @@ add_keyblock_resource( const char *filename, int force, int secret )
     return 0;
 }
 
+/****************
+ * Return the resource name of the keyblock associated with KBPOS.
+ */
+const char *
+keyblock_resource_name( KBPOS *kbpos )
+{
+    RESTBL *rentry;
+
+    if( !(rentry = check_pos( kbpos )) || !rentry->fname )
+       log_bug("no name for keyblock resource %d\n", kbpos->resno );
+    return rentry->fname;
+}
+
 
 /****************
  * Get a keyblock handle KBPOS from a filename. This can be used
  * to get a handle for insert_keyblock for a new keyblock.
+ * Using a filename of NULL returns the default resource
  */
 int
 get_keyblock_handle( const char *filename, int secret, KBPOS *kbpos )
@@ -129,7 +162,7 @@ get_keyblock_handle( const char *filename, int secret, KBPOS *kbpos )
     for(i=0; i < MAX_RESOURCES; i++ )
        if( resource_table[i].used && !resource_table[i].secret == !secret ) {
            /* fixme: dos needs case insensitive file compare */
-           if( !strcmp( resource_table[i].fname, filename ) ) {
+           if( !filename || !strcmp( resource_table[i].fname, filename ) ) {
                memset( kbpos, 0, sizeof *kbpos );
                kbpos->resno = i;
                return 0;
@@ -138,19 +171,21 @@ get_keyblock_handle( const char *filename, int secret, KBPOS *kbpos )
     return -1; /* not found */
 }
 
+
+
 /****************
- * Search a keyblock which starts with the given packet and put all
- * informations into KBPOS, which can be used later to access this key block.
+ * Search a keyblock which starts with the given packet and puts all
+ * information into KBPOS, which can be used later to access this key block.
  * This function looks into all registered keyblock sources.
- * PACKET must be a packet with either a secret_cert or a public_cert
+ * PACKET must be a packet with either a secret_key or a public_key
  *
- * This function is intended to check wether a given certificate
+ * This function is intended to check whether a given certificate
  * is already in a keyring or to prepare it for editing.
  *
  * Returns: 0 if found, -1 if not found or an errorcode.
  */
-int
-search_keyblock( PACKET *pkt, KBPOS *kbpos, int secret )
+static int
+search( PACKET *pkt, KBPOS *kbpos, int secret )
 {
     int i, rc, last_rc=-1;
 
@@ -158,9 +193,11 @@ search_keyblock( PACKET *pkt, KBPOS *kbpos, int secret )
        if( resource_table[i].used && !resource_table[i].secret == !secret ) {
            /* note: here we have to add different search functions,
             * depending on the type of the resource */
-           rc = keyring_search( pkt, kbpos, resource_table[i].iobuf );
+           rc = keyring_search( pkt, kbpos, resource_table[i].iobuf,
+                                            resource_table[i].fname );
            if( !rc ) {
                kbpos->resno = i;
+               kbpos->fp = NULL;
                return 0;
            }
            if( rc != -1 ) {
@@ -179,63 +216,81 @@ search_keyblock( PACKET *pkt, KBPOS *kbpos, int secret )
  * of the keyblock.
  */
 int
-search_keyblock_byname( KBPOS *kbpos, const char *username )
+find_keyblock_byname( KBPOS *kbpos, const char *username )
 {
     PACKET pkt;
-    PKT_public_cert *pkc = m_alloc_clear( sizeof *pkc );
+    PKT_public_key *pk = m_alloc_clear( sizeof *pk );
     int rc;
 
-    rc = get_pubkey_byname( pkc, username );
+    rc = get_pubkey_byname( pk, username );
     if( rc ) {
-       free_public_cert(pkc);
+       free_public_key(pk);
        return rc;
     }
 
     init_packet( &pkt );
-    pkt.pkttype = PKT_PUBLIC_CERT;
-    pkt.pkt.public_cert = pkc;
-    rc = search_keyblock( &pkt, kbpos, 0 );
-    free_public_cert(pkc);
+    pkt.pkttype = PKT_PUBLIC_KEY;
+    pkt.pkt.public_key = pk;
+    rc = search( &pkt, kbpos, 0 );
+    free_public_key(pk);
     return rc;
 }
 
+
+/****************
+ * Combined function to search for a key and get the position
+ * of the keyblock.
+ */
+int
+find_keyblock_bypk( KBPOS *kbpos, PKT_public_key *pk )
+{
+    PACKET pkt;
+    int rc;
+
+    init_packet( &pkt );
+    pkt.pkttype = PKT_PUBLIC_KEY;
+    pkt.pkt.public_key = pk;
+    rc = search( &pkt, kbpos, 0 );
+    return rc;
+}
+
+
 /****************
  * Combined function to search for a username and get the position
  * of the keyblock. This function does not unprotect the secret key.
  */
 int
-search_secret_keyblock_byname( KBPOS *kbpos, const char *username )
+find_secret_keyblock_byname( KBPOS *kbpos, const char *username )
 {
     PACKET pkt;
-    PKT_secret_cert *skc = m_alloc_clear( sizeof *skc );
+    PKT_secret_key *sk = m_alloc_clear( sizeof *sk );
     int rc;
 
-    rc = get_seckey_byname( skc, username, 0 );
+    rc = get_seckey_byname( sk, username, 0 );
     if( rc ) {
-       free_secret_cert(skc);
+       free_secret_key(sk);
        return rc;
     }
 
     init_packet( &pkt );
-    pkt.pkttype = PKT_SECRET_CERT;
-    pkt.pkt.secret_cert = skc;
-    rc = search_keyblock( &pkt, kbpos, 1 );
-    free_secret_cert(skc);
+    pkt.pkttype = PKT_SECRET_KEY;
+    pkt.pkt.secret_key = sk;
+    rc = search( &pkt, kbpos, 1 );
+    free_secret_key(sk);
     return rc;
 }
 
 
+
 /****************
  * Lock the keyblock; wait until it's available
  * This function may change the internal data in kbpos, in cases
- * when the to be locked keyblock has been modified.
- * fixme: remove this function and add an option to search_keyblock()?
+ * when the keyblock to be locked has been modified.
+ * fixme: remove this function and add an option to search()?
  */
 int
 lock_keyblock( KBPOS *kbpos )
 {
-    int rc;
-
     if( !check_pos(kbpos) )
        return G10ERR_GENERAL;
     return 0;
@@ -248,7 +303,7 @@ void
 unlock_keyblock( KBPOS *kbpos )
 {
     if( !check_pos(kbpos) )
-       log_bug(NULL);
+       BUG();
 }
 
 /****************
@@ -262,6 +317,88 @@ read_keyblock( KBPOS *kbpos, KBNODE *ret_root )
     return keyring_read( kbpos, ret_root );
 }
 
+
+/****************
+ * This functions can be used to read through a complete keyring.
+ * Mode is: 0 = open
+ *         1 = read
+ *         2 = close
+ *         5 = open secret keyrings
+ *         11 = read but skip signature and comment packets.
+ *         all others are reserved!
+ * Note that you do not need a search prior to this function,
+ * only a handle is needed.
+ * NOTE: It is not allowed to do an insert/update/delte with this
+ *      keyblock, if you want to do this, use search/read!
+ */
+int
+enum_keyblocks( int mode, KBPOS *kbpos, KBNODE *ret_root )
+{
+    int rc = 0;
+    RESTBL *rentry;
+
+    if( !mode || mode == 5 || mode == 100 ) {
+       int i;
+       kbpos->fp = NULL;
+       if( !mode ) {
+           kbpos->secret = 0;
+           i = 0;
+       }
+       else if( mode == 5 ) {
+           kbpos->secret = 1;
+           mode = 0;
+           i = 0;
+       }
+       else
+           i = kbpos->resno+1;
+       for(; i < MAX_RESOURCES; i++ )
+           if( resource_table[i].used
+               && !resource_table[i].secret == !kbpos->secret )
+               break;
+       if( i == MAX_RESOURCES )
+           return -1; /* no resources */
+       kbpos->resno = i;
+       rentry = check_pos( kbpos );
+       kbpos->fp = iobuf_open( rentry->fname );
+       if( !kbpos->fp ) {
+           log_error("can't open '%s'\n", rentry->fname );
+           return G10ERR_OPEN_FILE;
+       }
+       kbpos->pkt = NULL;
+    }
+    else if( mode == 1 || mode == 11 ) {
+       int cont;
+       do {
+           cont = 0;
+           if( !kbpos->fp )
+               return G10ERR_GENERAL;
+           rc = keyring_enum( kbpos, ret_root, mode == 11 );
+           if( rc == -1 ) {
+               assert( !kbpos->pkt );
+               rentry = check_pos( kbpos );
+               assert(rentry);
+               /* close */
+               enum_keyblocks(2, kbpos, ret_root );
+               /* and open the next one */
+               rc = enum_keyblocks(100, kbpos, ret_root );
+               if( !rc )
+                   cont = 1;
+           }
+       } while(cont);
+    }
+    else if( kbpos->fp ) {
+       iobuf_close( kbpos->fp );
+       kbpos->fp = NULL;
+       /* release pending packet */
+       free_packet( kbpos->pkt );
+       m_free( kbpos->pkt );
+    }
+    return rc;
+}
+
+
+
+
 /****************
  * Insert the keyblock described by ROOT into the keyring described
  * by KBPOS.  This actually appends the data to the keyfile.
@@ -274,7 +411,7 @@ insert_keyblock( KBPOS *kbpos, KBNODE root )
     if( !check_pos(kbpos) )
        return G10ERR_GENERAL;
 
-    rc = keyring_insert( kbpos, root );
+    rc = keyring_copy( kbpos, 1, root );
 
     return rc;
 }
@@ -282,7 +419,7 @@ insert_keyblock( KBPOS *kbpos, KBNODE root )
 /****************
  * Delete the keyblock described by KBPOS.
  * The current code simply changes the keyblock in the keyring
- * to packet of type 0 with the correct length.  To help detecting errors,
+ * to packet of type 0 with the correct length.  To help detect errors,
  * zero bytes are written.
  */
 int
@@ -293,7 +430,7 @@ delete_keyblock( KBPOS *kbpos )
     if( !check_pos(kbpos) )
        return G10ERR_GENERAL;
 
-    rc = keyring_delete( kbpos );
+    rc = keyring_copy( kbpos, 2, NULL );
 
     return rc;
 }
@@ -306,14 +443,11 @@ int
 update_keyblock( KBPOS *kbpos, KBNODE root )
 {
     int rc;
-    KBPOS kbpos2;
 
-    /* we do it the simple way: */
-    memset( &kbpos2, 0, sizeof kbpos2 );
-    kbpos2.resno = kbpos->resno;
-    rc = insert_keyblock( &kbpos2, root );
-    if( !rc )
-       rc = delete_keyblock( kbpos );
+    if( !check_pos(kbpos) )
+       return G10ERR_GENERAL;
+
+    rc = keyring_copy( kbpos, 3, root );
 
     return rc;
 }
@@ -323,73 +457,90 @@ update_keyblock( KBPOS *kbpos, KBNODE root )
  ********** Functions which operates on regular keyrings ********
  ****************************************************************/
 
+static int
+cmp_seckey( PKT_secret_key *req_sk, PKT_secret_key *sk )
+{
+    int n,i;
+
+    assert( req_sk->pubkey_algo == sk->pubkey_algo );
+
+    n = pubkey_get_nskey( req_sk->pubkey_algo );
+    for(i=0; i < n; i++ ) {
+       if( mpi_cmp( req_sk->skey[i], sk->skey[i] ) )
+           return -1;
+    }
+    return 0;
+}
+
+static int
+cmp_pubkey( PKT_public_key *req_pk, PKT_public_key *pk )
+{
+    int n, i;
+
+    assert( req_pk->pubkey_algo == pk->pubkey_algo );
+
+    n = pubkey_get_npkey( req_pk->pubkey_algo );
+    for(i=0; i < n; i++ ) {
+       if( mpi_cmp( req_pk->pkey[i], pk->pkey[i] )  )
+           return -1;
+    }
+    return 0;
+}
 
 /****************
  * search one keyring, return 0 if found, -1 if not found or an errorcode.
  */
 static int
-keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf )
+keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf, const char *fname )
 {
     int rc;
     PACKET pkt;
     int save_mode;
     ulong offset;
     int pkttype = req->pkttype;
-    PKT_public_cert *req_pkc = req->pkt.public_cert;
-    PKT_secret_cert *req_skc = req->pkt.secret_cert;
+    PKT_public_key *req_pk = req->pkt.public_key;
+    PKT_secret_key *req_sk = req->pkt.secret_key;
 
     init_packet(&pkt);
     save_mode = set_packet_list_mode(0);
 
+  #if __MINGW32__
+    assert(!iobuf);
+    iobuf = iobuf_open( fname );
+    if( !iobuf ) {
+       log_error("%s: can't open keyring file\n", fname);
+       rc = G10ERR_KEYRING_OPEN;
+       goto leave;
+    }
+  #else
     if( iobuf_seek( iobuf, 0 ) ) {
-       log_error("can't rewind keyring file: %s\n", g10_errstr(rc));
+       log_error("can't rewind keyring file\n");
        rc = G10ERR_KEYRING_OPEN;
        goto leave;
     }
+  #endif
 
     while( !(rc=search_packet(iobuf, &pkt, pkttype, &offset)) ) {
-       if( pkt.pkttype == PKT_SECRET_CERT ) {
-           PKT_secret_cert *skc = pkt.pkt.secret_cert;
-
-           if(   req_skc->timestamp == skc->timestamp
-              && req_skc->valid_days == skc->valid_days
-              && req_skc->pubkey_algo == skc->pubkey_algo
-              && (   ( skc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
-                       && !mpi_cmp( req_skc->d.elg.p, skc->d.elg.p )
-                       && !mpi_cmp( req_skc->d.elg.g, skc->d.elg.g )
-                       && !mpi_cmp( req_skc->d.elg.y, skc->d.elg.y )
-                       && !mpi_cmp( req_skc->d.elg.x, skc->d.elg.x )
-                     )
-                  || ( skc->pubkey_algo == PUBKEY_ALGO_RSA
-                       && !mpi_cmp( req_skc->d.rsa.rsa_n, skc->d.rsa.rsa_n )
-                       && !mpi_cmp( req_skc->d.rsa.rsa_e, skc->d.rsa.rsa_e )
-                       && !mpi_cmp( req_skc->d.rsa.rsa_d, skc->d.rsa.rsa_d )
-                     )
-                 )
-             )
+       if( pkt.pkttype == PKT_SECRET_KEY ) {
+           PKT_secret_key *sk = pkt.pkt.secret_key;
+
+           if(   req_sk->timestamp == sk->timestamp
+              && req_sk->valid_days == sk->valid_days
+              && req_sk->pubkey_algo == sk->pubkey_algo
+              && !cmp_seckey( req_sk, sk) )
                break; /* found */
        }
-       else if( pkt.pkttype == PKT_PUBLIC_CERT ) {
-           PKT_public_cert *pkc = pkt.pkt.public_cert;
-
-           if(   req_pkc->timestamp == pkc->timestamp
-              && req_pkc->valid_days == pkc->valid_days
-              && req_pkc->pubkey_algo == pkc->pubkey_algo
-              && (   ( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
-                       && !mpi_cmp( req_pkc->d.elg.p, pkc->d.elg.p )
-                       && !mpi_cmp( req_pkc->d.elg.g, pkc->d.elg.g )
-                       && !mpi_cmp( req_pkc->d.elg.y, pkc->d.elg.y )
-                     )
-                  || ( pkc->pubkey_algo == PUBKEY_ALGO_RSA
-                       && !mpi_cmp( req_pkc->d.rsa.rsa_n, pkc->d.rsa.rsa_n )
-                       && !mpi_cmp( req_pkc->d.rsa.rsa_e, pkc->d.rsa.rsa_e )
-                     )
-                 )
-             )
+       else if( pkt.pkttype == PKT_PUBLIC_KEY ) {
+           PKT_public_key *pk = pkt.pkt.public_key;
+
+           if(   req_pk->timestamp == pk->timestamp
+              && req_pk->valid_days == pk->valid_days
+              && req_pk->pubkey_algo == pk->pubkey_algo
+              && !cmp_pubkey( req_pk, pk ) )
                break; /* found */
        }
        else
-           log_bug(NULL);
+           BUG();
        free_packet(&pkt);
     }
     if( !rc )
@@ -398,6 +549,9 @@ keyring_search( PACKET *req, KBPOS *kbpos, IOBUF iobuf )
   leave:
     free_packet(&pkt);
     set_packet_list_mode(save_mode);
+  #if __MINGW32__
+    iobuf_close(iobuf);
+  #endif
     return rc;
 }
 
@@ -409,9 +563,8 @@ keyring_read( KBPOS *kbpos, KBNODE *ret_root )
     int rc;
     RESTBL *rentry;
     KBNODE root = NULL;
-    KBNODE node, n1, n2;
     IOBUF a;
-    u32 offset, last_offset;
+    int in_cert = 0;
 
     if( !(rentry=check_pos(kbpos)) )
        return G10ERR_GENERAL;
@@ -423,205 +576,318 @@ keyring_read( KBPOS *kbpos, KBNODE *ret_root )
     }
 
     if( iobuf_seek( a, kbpos->offset ) ) {
-       log_error("can't seek to %lu: %s\n", kbpos->offset, g10_errstr(rc));
+       log_error("can't seek to %lu\n", kbpos->offset);
        iobuf_close(a);
        return G10ERR_KEYRING_OPEN;
     }
 
     pkt = m_alloc( sizeof *pkt );
     init_packet(pkt);
+    kbpos->count=0;
     while( (rc=parse_packet(a, pkt)) != -1 ) {
        if( rc ) {  /* ignore errors */
+           if( rc != G10ERR_UNKNOWN_PACKET ) {
+               log_error("read_keyblock: read error: %s\n", g10_errstr(rc) );
+               rc = G10ERR_INV_KEYRING;
+               goto ready;
+           }
+           kbpos->count++;
            free_packet( pkt );
+           init_packet( pkt );
            continue;
        }
-       if( root && ( pkt->pkttype == PKT_PUBLIC_CERT
-                     || pkt->pkttype == PKT_SECRET_CERT ) )
-           goto ready;
-       offset = iobuf_tell(a);
+       /* make a linked list of all packets */
        switch( pkt->pkttype ) {
-         case PKT_PUBLIC_CERT:
-         case PKT_SECRET_CERT:
-           root = new_kbnode( pkt );
+         case PKT_PUBLIC_KEY:
+         case PKT_SECRET_KEY:
+           if( in_cert )
+               goto ready;
+           in_cert = 1;
+         default:
+           kbpos->count++;
+           if( !root )
+               root = new_kbnode( pkt );
+           else
+               add_kbnode( root, new_kbnode( pkt ) );
            pkt = m_alloc( sizeof *pkt );
            init_packet(pkt);
            break;
+       }
+    }
+  ready:
+    if( rc == -1 && root )
+       rc = 0;
 
-         case PKT_USER_ID:
-           if( !root ) {
-               log_error("read_keyblock: orphaned user id\n" );
-               rc = G10ERR_INV_KEYRING; /* or wrong kbpos */
+    if( rc )
+       release_kbnode( root );
+    else
+       *ret_root = root;
+    free_packet( pkt );
+    m_free( pkt );
+    iobuf_close(a);
+    return rc;
+}
+
+
+static int
+keyring_enum( KBPOS *kbpos, KBNODE *ret_root, int skipsigs )
+{
+    PACKET *pkt;
+    int rc;
+    RESTBL *rentry;
+    KBNODE root = NULL;
+
+    if( !(rentry=check_pos(kbpos)) )
+       return G10ERR_GENERAL;
+
+    if( kbpos->pkt ) {
+       root = new_kbnode( kbpos->pkt );
+       kbpos->pkt = NULL;
+    }
+
+    pkt = m_alloc( sizeof *pkt );
+    init_packet(pkt);
+    while( (rc=parse_packet(kbpos->fp, pkt)) != -1 ) {
+       if( rc ) {  /* ignore errors */
+           if( rc != G10ERR_UNKNOWN_PACKET ) {
+               log_error("read_keyblock: read error: %s\n", g10_errstr(rc) );
+               rc = G10ERR_INV_KEYRING;
                goto ready;
            }
-           offset = last_offset;
-           /* append the user id */
-           node = new_kbnode( pkt );
-           if( !(n1=root->child) )
-               root->child = node;
-           else {
-               for( ; n1->next; n1 = n1->next)
-                   ;
-               n1->next = node;
+           free_packet( pkt );
+           init_packet( pkt );
+           continue;
+       }
+       /* make a linked list of all packets */
+       switch( pkt->pkttype ) {
+         case PKT_PUBLIC_KEY:
+         case PKT_SECRET_KEY:
+           if( root ) { /* store this packet */
+               kbpos->pkt = pkt;
+               pkt = NULL;
+               goto ready;
            }
+           root = new_kbnode( pkt );
            pkt = m_alloc( sizeof *pkt );
            init_packet(pkt);
            break;
 
-         case PKT_SIGNATURE:
-           if( !root ) {
-               log_error("read_keyblock: no root for signature\n" );
-               rc = G10ERR_INV_KEYRING; /* or wrong kbpos */
-               break;
-           }
-           if( !root->child ) {
-               log_error("read_keyblock: no userid for signature\n" );
-               rc = G10ERR_INV_KEYRING;
+         default:
+           /* skip pakets at the beginning of a keyring, until we find
+            * a start packet; issue a warning if it is not a comment */
+           if( !root && pkt->pkttype != PKT_COMMENT
+                     && pkt->pkttype != PKT_OLD_COMMENT )
+               log_info("keyring_enum: skipped packet of type %d\n",
+                           pkt->pkttype );
+           if( !root || (skipsigs && ( pkt->pkttype == PKT_SIGNATURE
+                                     ||pkt->pkttype == PKT_COMMENT
+                                     ||pkt->pkttype == PKT_OLD_COMMENT )) ) {
+               init_packet(pkt);
                break;
            }
-           /* goto the last user id */
-           for(n1=root->child; n1->next; n1 = n1->next )
-               ;
-           /* append the signature node */
-           node = new_kbnode( pkt );
-           if( !(n2=n1->child) )
-               n1->child = node;
-           else {
-               for( ; n2->next; n2 = n2->next)
-                   ;
-               n2->next = node;
-           }
+           add_kbnode( root, new_kbnode( pkt ) );
            pkt = m_alloc( sizeof *pkt );
            init_packet(pkt);
            break;
-
-         default: /* ignore all other packets. FIXME: we should not do this */
-           free_packet( pkt );
-           break;
        }
     }
   ready:
-    kbpos->last_block = rc == -1; /* flag, that this is the last block */
     if( rc == -1 && root )
        rc = 0;
 
     if( rc )
        release_kbnode( root );
-    else {
+    else
        *ret_root = root;
-       kbpos->length = offset - kbpos->offset;
-    }
     free_packet( pkt );
     m_free( pkt );
-    iobuf_close(a);
     return rc;
 }
 
 
+
 /****************
- * Insert the keyblock described by ROOT into the keyring described
- * by KBPOS.  This actually appends the data to the keyfile.
+ * Perform insert/delete/update operation.
+ * mode 1 = insert
+ *     2 = delete
+ *     3 = update
  */
 static int
-keyring_insert( KBPOS *kbpos, KBNODE root )
+keyring_copy( KBPOS *kbpos, int mode, KBNODE root )
 {
     RESTBL *rentry;
-    IOBUF fp;
-    KBNODE kbctx, node;
-    int rc;
+    IOBUF fp, newfp;
+    int rc=0;
+    char *bakfname = NULL;
+    char *tmpfname = NULL;
 
     if( !(rentry = check_pos( kbpos )) )
        return G10ERR_GENERAL;
-
-    /* FIXME: we must close the file if it's already open, due to
-     *       2 reasons:
-     *        - cannot open the same file twice on DOSish OSes
-     *        - must sync with iobufs somehow
-     */
-    /* open the file for append */
-    fp = iobuf_append( rentry->fname );
-    if( !fp ) {
-       log_error("can't append to '%s'\n", rentry->fname );
-       return G10ERR_OPEN_FILE;
-    }
-
-    kbctx=NULL;
-    while( (node = walk_kbtree( root, &kbctx )) ) {
-       if( (rc = build_packet( fp, node->pkt )) ) {
-           log_error("build_packet(%d) failed: %s\n",
-                       node->pkt->pkttype, g10_errstr(rc) );
+    if( kbpos->fp )
+       BUG(); /* not allowed with such a handle */
+
+    /* open the source file */
+    fp = iobuf_open( rentry->fname );
+    if( mode == 1 && !fp && errno == ENOENT ) { /* no file yet */
+       KBNODE kbctx, node;
+
+       /* insert: create a new file */
+       newfp = iobuf_create( rentry->fname );
+       if( !newfp ) {
+           log_error("%s: can't create: %s\n", rentry->fname, strerror(errno));
+           return G10ERR_OPEN_FILE;
+       }
+       else
+           log_info("%s: keyring created\n", rentry->fname );
+
+       kbctx=NULL;
+       while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
+           if( (rc = build_packet( newfp, node->pkt )) ) {
+               log_error("build_packet(%d) failed: %s\n",
+                           node->pkt->pkttype, g10_errstr(rc) );
+               iobuf_cancel(newfp);
+               return G10ERR_WRITE_FILE;
+           }
+       }
+       if( iobuf_close(newfp) ) {
+           log_error("%s: close failed: %s\n", rentry->fname, strerror(errno));
+           return G10ERR_CLOSE_FILE;
+       }
+       if( chmod( rentry->fname, S_IRUSR | S_IWUSR ) ) {
+           log_error("%s: chmod failed: %s\n",
+                                   rentry->fname, strerror(errno) );
            return G10ERR_WRITE_FILE;
        }
+       return 0;
     }
-    iobuf_close(fp);
-
-    return 0;
-}
-
-static int
-keyring_delete( KBPOS *kbpos )
-{
-    RESTBL *rentry;
-    IOBUF fp;
-    KBNODE kbctx, node;
-    int rc;
-    u32 len;
-    int ctb;
-
-    if( !(rentry = check_pos( kbpos )) )
-       return G10ERR_GENERAL;
-
-
-    /* open the file for read/write */
-    fp = iobuf_openrw( rentry->fname );
     if( !fp ) {
-       log_error("can't open '%s' for writing\n", rentry->fname );
-       return G10ERR_OPEN_FILE;
+       log_error("%s: can't open: %s\n", rentry->fname, strerror(errno) );
+       rc = G10ERR_OPEN_FILE;
+       goto leave;
     }
 
-    if( iobuf_seek( fp, kbpos->offset ) ) {
-       log_error("can't seek to %lu: %s\n", kbpos->offset, g10_errstr(rc));
+    /* create the new file */
+    bakfname = m_alloc( strlen( rentry->fname ) + 2 );
+    strcpy(stpcpy(bakfname,rentry->fname),"~");
+    tmpfname = m_alloc( strlen( rentry->fname ) + 5 );
+    strcpy(stpcpy(tmpfname,rentry->fname),".tmp");
+    newfp = iobuf_create( tmpfname );
+    if( !newfp ) {
+       log_error("%s: can't create: %s\n", tmpfname, strerror(errno) );
        iobuf_close(fp);
-       return G10ERR_WRITE_FILE;
+       rc = G10ERR_OPEN_FILE;
+       goto leave;
     }
 
-    len = kbpos->length;
-    /*log_debug("writing a dummy packet of length %lu\n", (ulong)len);*/
-
-    if( len < 2 )
-       log_bug(NULL);
+    if( mode == 1 ) { /* insert */
+       /* copy everything to the new file */
+       rc = copy_all_packets( fp, newfp );
+       if( rc != -1 ) {
+           log_error("%s: copy to %s failed: %s\n",
+                     rentry->fname, tmpfname, g10_errstr(rc) );
+           iobuf_close(fp);
+           iobuf_cancel(newfp);
+           goto leave;
+       }
+       rc = 0;
+    }
 
-    if( len < 256 ) {
-       ctb = 0x80;
-       len -= 2;
+    if( mode == 2 || mode == 3 ) { /* delete or update */
+       /* copy first part to the new file */
+       rc = copy_some_packets( fp, newfp, kbpos->offset );
+       if( rc ) { /* should never get EOF here */
+           log_error("%s: copy to %s failed: %s\n",
+                     rentry->fname, tmpfname, g10_errstr(rc) );
+           iobuf_close(fp);
+           iobuf_cancel(newfp);
+           goto leave;
+       }
+       /* skip this keyblock */
+       assert( kbpos->count );
+       rc = skip_some_packets( fp, kbpos->count );
+       if( rc ) {
+           log_error("%s: skipping %u packets failed: %s\n",
+                           rentry->fname, kbpos->count, g10_errstr(rc));
+           iobuf_close(fp);
+           iobuf_cancel(newfp);
+           goto leave;
+       }
     }
-    else if( len < 65536 ) {
-       ctb = 0x81;
-       len -= 3;
+
+    if( mode == 1 || mode == 3 ) { /* insert or update */
+       KBNODE kbctx, node;
+
+       /* append the new data */
+       kbctx=NULL;
+       while( (node = walk_kbnode( root, &kbctx, 0 )) ) {
+           if( (rc = build_packet( newfp, node->pkt )) ) {
+               log_error("build_packet(%d) failed: %s\n",
+                           node->pkt->pkttype, g10_errstr(rc) );
+               iobuf_close(fp);
+               iobuf_cancel(newfp);
+               rc = G10ERR_WRITE_FILE;
+               goto leave;
+           }
+       }
     }
-    else {
-       ctb = 0x82;
-       len -= 5;
+
+    if( mode == 2 || mode == 3 ) { /* delete or update */
+       /* copy the rest */
+       rc = copy_all_packets( fp, newfp );
+       if( rc != -1 ) {
+           log_error("%s: copy to %s failed: %s\n",
+                     rentry->fname, tmpfname, g10_errstr(rc) );
+           iobuf_close(fp);
+           iobuf_cancel(newfp);
+           goto leave;
+       }
+       rc = 0;
     }
-    iobuf_put(fp, ctb );
-    if( ctb & 2 ) {
-       iobuf_put(fp, len >> 24 );
-       iobuf_put(fp, len >> 16 );
+
+    /* close both files */
+    if( iobuf_close(fp) ) {
+       log_error("%s: close failed: %s\n", rentry->fname, strerror(errno) );
+       rc = G10ERR_CLOSE_FILE;
+       goto leave;
     }
-    if( ctb & 3 )
-       iobuf_put(fp, len >> 8 );
-    if( iobuf_put(fp, len ) ) {
-       iobuf_close(fp);
-       return G10ERR_WRITE_FILE;
+    if( iobuf_close(newfp) ) {
+       log_error("%s: close failed: %s\n", tmpfname, strerror(errno) );
+       rc = G10ERR_CLOSE_FILE;
+       goto leave;
     }
-    for( ; len; len-- )
-       if( iobuf_put(fp, 0xff ) ) {
-           iobuf_close(fp);
-           return G10ERR_WRITE_FILE;
+    /* if the new file is a secring, restrict the permissions */
+    if( rentry->secret ) {
+       if( chmod( tmpfname, S_IRUSR | S_IWUSR ) ) {
+           log_error("%s: chmod failed: %s\n",
+                                   tmpfname, strerror(errno) );
+           rc = G10ERR_WRITE_FILE;
+           goto leave;
        }
+    }
+    /* rename and make backup file */
+  #if __MINGW32__
+    remove( bakfname );
+  #endif
+    if( rename( rentry->fname, bakfname ) ) {
+       log_error("%s: rename to %s failed: %s\n",
+                               rentry->fname, bakfname, strerror(errno) );
+       rc = G10ERR_RENAME_FILE;
+       goto leave;
+    }
+  #if __MINGW32__
+    remove( rentry->fname );
+  #endif
+    if( rename( tmpfname, rentry->fname ) ) {
+       log_error("%s: rename to %s failed: %s\n",
+                           tmpfname, rentry->fname,strerror(errno) );
+       rc = G10ERR_RENAME_FILE;
+       goto leave;
+    }
 
-    iobuf_close(fp);
-
-    return 0;
+  leave:
+    m_free(bakfname);
+    m_free(tmpfname);
+    return rc;
 }