g10/kbnode.c

   1 /* kbnode.c -  keyblock node utility functions
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
   3  *               2005 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  20  * USA.
  21  */
  22
  23 #include <config.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <assert.h>
  28
  29 #include "gpg.h"
  30 #include "util.h"
  31 #include "packet.h"
  32 #include "keydb.h"
  33
  34 #define USE_UNUSED_NODES 1
  35
  36 static KBNODE unused_nodes;
  37
  38 static KBNODE
  39 alloc_node(void)
  40 {
  41     KBNODE n;
  42
  43     n = unused_nodes;
  44     if( n )
  45         unused_nodes = n->next;
  46     else
  47         n = xmalloc( sizeof *n );
  48     n->next = NULL;
  49     n->pkt = NULL;
  50     n->flag = 0;
  51     n->private_flag=0;
  52     n->recno = 0;
  53     return n;
  54 }
  55
  56 static void
  57 free_node( KBNODE n )
  58 {
  59     if( n ) {
  60 #if USE_UNUSED_NODES
  61         n->next = unused_nodes;
  62         unused_nodes = n;
  63 #else
  64         xfree( n );
  65 #endif
  66     }
  67 }
  68
  69
  70
  71 KBNODE
  72 new_kbnode( PACKET *pkt )
  73 {
  74     KBNODE n = alloc_node();
  75     n->pkt = pkt;
  76     return n;
  77 }
  78
  79
  80 KBNODE
  81 clone_kbnode( KBNODE node )
  82 {
  83     KBNODE n = alloc_node();
  84
  85     n->pkt = node->pkt;
  86     n->private_flag = node->private_flag | 2; /* mark cloned */
  87     return n;
  88 }
  89
  90
  91 void
  92 release_kbnode( KBNODE n )
  93 {
  94     KBNODE n2;
  95
  96     while( n ) {
  97         n2 = n->next;
  98         if( !is_cloned_kbnode(n) ) {
  99             free_packet( n->pkt );
 100             xfree( n->pkt );
 101         }
 102         free_node( n );
 103         n = n2;
 104     }
 105 }
 106
 107
 108 /****************
 109  * Delete NODE.
 110  * Note: This only works with walk_kbnode!!
 111  */
 112 void
 113 delete_kbnode( KBNODE node )
 114 {
 115     node->private_flag |= 1;
 116 }
 117
 118 /****************
 119  * Append NODE to ROOT.  ROOT must exist!
 120  */
 121 void
 122 add_kbnode( KBNODE root, KBNODE node )
 123 {
 124     KBNODE n1;
 125
 126     for(n1=root; n1->next; n1 = n1->next)
 127         ;
 128     n1->next = node;
 129 }
 130
 131 /****************
 132  * Insert NODE into the list after root but before a packet which is not of
 133  * type PKTTYPE
 134  * (only if PKTTYPE != 0)
 135  */
 136 void
 137 insert_kbnode( KBNODE root, KBNODE node, int pkttype )
 138 {
 139     if( !pkttype ) {
 140         node->next = root->next;
 141         root->next = node;
 142     }
 143     else {
 144         KBNODE n1;
 145
 146         for(n1=root; n1->next;  n1 = n1->next)
 147             if( pkttype != n1->next->pkt->pkttype ) {
 148                 node->next = n1->next;
 149                 n1->next = node;
 150                 return;
 151             }
 152         /* no such packet, append */
 153         node->next = NULL;
 154         n1->next = node;
 155     }
 156 }
 157
 158
 159 /****************
 160  * Find the previous node (if PKTTYPE = 0) or the previous node
 161  * with pkttype PKTTYPE in the list starting with ROOT of NODE.
 162  */
 163 KBNODE
 164 find_prev_kbnode( KBNODE root, KBNODE node, int pkttype )
 165 {
 166     KBNODE n1;
 167
 168     for (n1=NULL; root && root != node; root = root->next ) {
 169         if (!pkttype ||root->pkt->pkttype == pkttype)
 170             n1 = root;
 171     }
 172     return n1;
 173 }
 174
 175 /****************
 176  * Ditto, but find the next packet.  The behaviour is trivial if
 177  * PKTTYPE is 0 but if it is specified, the next node with a packet
 178  * of this type is returned.  The function has some knowledge about
 179  * the valid ordering of packets: e.g. if the next signature packet
 180  * is requested, the function will not return one if it encounters
 181  * a user-id.
 182  */
 183 KBNODE
 184 find_next_kbnode( KBNODE node, int pkttype )
 185 {
 186     for( node=node->next ; node; node = node->next ) {
 187         if( !pkttype )
 188             return node;
 189         else if( pkttype == PKT_USER_ID
 190                  && (   node->pkt->pkttype == PKT_PUBLIC_KEY
 191                      || node->pkt->pkttype == PKT_SECRET_KEY ) )
 192             return NULL;
 193         else if( pkttype == PKT_SIGNATURE
 194                  && (   node->pkt->pkttype == PKT_USER_ID
 195                      || node->pkt->pkttype == PKT_PUBLIC_KEY
 196                      || node->pkt->pkttype == PKT_SECRET_KEY ) )
 197             return NULL;
 198         else if( node->pkt->pkttype == pkttype )
 199             return node;
 200     }
 201     return NULL;
 202 }
 203
 204
 205 KBNODE
 206 find_kbnode( KBNODE node, int pkttype )
 207 {
 208     for( ; node; node = node->next ) {
 209         if( node->pkt->pkttype == pkttype )
 210             return node;
 211     }
 212     return NULL;
 213 }
 214
 215
 216
 217 /****************
 218  * Walk through a list of kbnodes. This function returns
 219  * the next kbnode for each call; before using the function the first
 220  * time, the caller must set CONTEXT to NULL (This has simply the effect
 221  * to start with ROOT).
 222  */
 223 KBNODE
 224 walk_kbnode( KBNODE root, KBNODE *context, int all )
 225 {
 226     KBNODE n;
 227
 228     do {
 229         if( !*context ) {
 230             *context = root;
 231             n = root;
 232         }
 233         else {
 234             n = (*context)->next;
 235             *context = n;
 236         }
 237     } while( !all && n && is_deleted_kbnode(n) );
 238
 239     return n;
 240 }
 241
 242 void
 243 clear_kbnode_flags( KBNODE n )
 244 {
 245     for( ; n; n = n->next ) {
 246         n->flag = 0;
 247     }
 248 }
 249
 250
 251 /****************
 252  * Commit changes made to the kblist at ROOT. Note that ROOT my change,
 253  * and it is therefore passed by reference.
 254  * The function has the effect of removing all nodes marked as deleted.
 255  * returns true if any node has been changed
 256  */
 257 int
 258 commit_kbnode( KBNODE *root )
 259 {
 260     KBNODE n, nl;
 261     int changed = 0;
 262
 263     for( n = *root, nl=NULL; n; n = nl->next ) {
 264         if( is_deleted_kbnode(n) ) {
 265             if( n == *root )
 266                 *root = nl = n->next;
 267             else
 268                 nl->next = n->next;
 269             if( !is_cloned_kbnode(n) ) {
 270                 free_packet( n->pkt );
 271                 xfree( n->pkt );
 272             }
 273             free_node( n );
 274             changed = 1;
 275         }
 276         else
 277             nl = n;
 278     }
 279     return changed;
 280 }
 281
 282 void
 283 remove_kbnode( KBNODE *root, KBNODE node )
 284 {
 285     KBNODE n, nl;
 286
 287     for( n = *root, nl=NULL; n; n = nl->next ) {
 288         if( n == node ) {
 289             if( n == *root )
 290                 *root = nl = n->next;
 291             else
 292                 nl->next = n->next;
 293             if( !is_cloned_kbnode(n) ) {
 294                 free_packet( n->pkt );
 295                 xfree( n->pkt );
 296             }
 297             free_node( n );
 298         }
 299         else
 300             nl = n;
 301     }
 302 }
 303
 304
 305 /****************
 306  * Move NODE behind right after WHERE or to the beginning if WHERE is NULL.
 307  */
 308 void
 309 move_kbnode( KBNODE *root, KBNODE node, KBNODE where )
 310 {
 311     KBNODE tmp, prev;
 312
 313     if( !root || !*root || !node )
 314         return;  /* sanity check */
 315     for( prev = *root; prev && prev->next != node; prev = prev->next )
 316         ;
 317     if( !prev )
 318         return; /* node is not in the list */
 319
 320     if( !where ) {  /* move node before root */
 321         if( node == *root ) /* move to itself */
 322             return;
 323         prev->next = node->next;
 324         node->next = *root;
 325         *root = node;
 326         return;
 327     }
 328     /* move it after where */
 329     if( node == where )
 330         return;
 331     tmp = node->next;
 332     node->next = where->next;
 333     where->next = node;
 334     prev->next = tmp;
 335 }
 336
 337
 338
 339
 340 void
 341 dump_kbnode( KBNODE node )
 342 {
 343     for(; node; node = node->next ) {
 344         const char *s;
 345         switch( node->pkt->pkttype ) {
 346           case 0:               s="empty"; break;
 347           case PKT_PUBLIC_KEY:  s="public-key"; break;
 348           case PKT_SECRET_KEY:  s="secret-key"; break;
 349           case PKT_SECRET_SUBKEY: s= "secret-subkey"; break;
 350           case PKT_PUBKEY_ENC:  s="public-enc"; break;
 351           case PKT_SIGNATURE:   s="signature"; break;
 352           case PKT_ONEPASS_SIG: s="onepass-sig"; break;
 353           case PKT_USER_ID:     s="user-id"; break;
 354           case PKT_PUBLIC_SUBKEY: s="public-subkey"; break;
 355           case PKT_COMMENT:     s="comment"; break;
 356           case PKT_RING_TRUST:  s="trust"; break;
 357           case PKT_PLAINTEXT:   s="plaintext"; break;
 358           case PKT_COMPRESSED:  s="compressed"; break;
 359           case PKT_ENCRYPTED:   s="encrypted"; break;
 360           case PKT_GPG_CONTROL: s="gpg-control"; break;
 361           default:              s="unknown"; break;
 362         }
 363         fprintf(stderr, "node %p %02x/%02x type=%s",
 364                 node, node->flag, node->private_flag, s);
 365         if( node->pkt->pkttype == PKT_USER_ID ) {
 366             PKT_user_id *uid = node->pkt->pkt.user_id;
 367             fputs("  \"", stderr);
 368             print_string( stderr, uid->name, uid->len, 0 );
 369             fprintf (stderr, "\" %c%c%c%c\n",
 370                      uid->is_expired? 'e':'.',
 371                      uid->is_revoked? 'r':'.',
 372                      uid->created?    'v':'.',
 373                      uid->is_primary? 'p':'.' );
 374         }
 375         else if( node->pkt->pkttype == PKT_SIGNATURE ) {
 376             fprintf(stderr, "  class=%02x keyid=%08lX ts=%lu\n",
 377                    node->pkt->pkt.signature->sig_class,
 378                    (ulong)node->pkt->pkt.signature->keyid[1],
 379                    (ulong)node->pkt->pkt.signature->timestamp);
 380         }
 381         else if( node->pkt->pkttype == PKT_GPG_CONTROL ) {
 382             fprintf(stderr, " ctrl=%d len=%u\n",
 383                     node->pkt->pkt.gpg_control->control,
 384                     (unsigned int)node->pkt->pkt.gpg_control->datalen);
 385         }
 386         else if( node->pkt->pkttype == PKT_PUBLIC_KEY
 387                  || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
 388             PKT_public_key *pk = node->pkt->pkt.public_key;
 389             fprintf(stderr, "  keyid=%08lX a=%d u=%d %c%c%c%c\n",
 390                     (ulong)keyid_from_pk( pk, NULL ),
 391                     pk->pubkey_algo, pk->pubkey_usage,
 392                     pk->has_expired? 'e':'.',
 393                     pk->is_revoked?  'r':'.',
 394                     pk->is_valid?    'v':'.',
 395                     pk->mdc_feature? 'm':'.');
 396         }
 397         else
 398             fputs("\n", stderr);
 399     }
 400 }