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