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