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