See ChangeLog: Wed Oct 4 13:16:18 CEST 2000 Werner Koch
[gnupg.git] / g10 / kbnode.c
1 /* kbnode.c -  keyblock node utility functions
2  *      Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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 <gcrypt.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 = gcry_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         gcry_free( 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             gcry_free( 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
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     return n1;
172 }
173
174 /****************
175  * Ditto, but find the next packet.  The behaviour is trivial if
176  * PKTTYPE is 0 but if it is specified, the next node with a packet
177  * of this type is returned.  The function has some knowledge about
178  * the valid ordering of packets: e.g. if the next signature packet
179  * is requested, the function will not return one if it encounters
180  * a user-id.
181  */
182 KBNODE
183 find_next_kbnode( KBNODE node, int pkttype )
184 {
185     for( node=node->next ; node; node = node->next ) {
186         if( !pkttype )
187             return node;
188         else if( pkttype == PKT_USER_ID
189                  && (   node->pkt->pkttype == PKT_PUBLIC_KEY
190                      || node->pkt->pkttype == PKT_SECRET_KEY ) )
191             return NULL;
192         else if( pkttype == PKT_SIGNATURE
193                  && (   node->pkt->pkttype == PKT_USER_ID
194                      || node->pkt->pkttype == PKT_PUBLIC_KEY
195                      || node->pkt->pkttype == PKT_SECRET_KEY ) )
196             return NULL;
197         else if( node->pkt->pkttype == pkttype )
198             return node;
199     }
200     return NULL;
201 }
202
203
204 KBNODE
205 find_kbnode( KBNODE node, int pkttype )
206 {
207     for( ; node; node = node->next ) {
208         if( node->pkt->pkttype == pkttype )
209             return node;
210     }
211     return NULL;
212 }
213
214
215
216 /****************
217  * Walk through a list of kbnodes. This function returns
218  * the next kbnode for each call; before using the function the first
219  * time, the caller must set CONTEXT to NULL (This has simply the effect
220  * to start with ROOT).
221  */
222 KBNODE
223 walk_kbnode( KBNODE root, KBNODE *context, int all )
224 {
225     KBNODE n;
226
227     do {
228         if( !*context ) {
229             *context = root;
230             n = root;
231         }
232         else {
233             n = (*context)->next;
234             *context = n;
235         }
236     } while( !all && n && is_deleted_kbnode(n) );
237
238     return n;
239 }
240
241 void
242 clear_kbnode_flags( KBNODE n )
243 {
244     for( ; n; n = n->next ) {
245         n->flag = 0;
246     }
247 }
248
249
250 /****************
251  * Commit changes made to the kblist at ROOT. Note that ROOT my change,
252  * and it is therefore passed by reference.
253  * The function has the effect of removing all nodes marked as deleted.
254  * returns true if any node has been changed
255  */
256 int
257 commit_kbnode( KBNODE *root )
258 {
259     KBNODE n, nl;
260     int changed = 0;
261
262     for( n = *root, nl=NULL; n; n = nl->next ) {
263         if( is_deleted_kbnode(n) ) {
264             if( n == *root )
265                 *root = nl = n->next;
266             else
267                 nl->next = n->next;
268             if( !is_cloned_kbnode(n) ) {
269                 free_packet( n->pkt );
270                 gcry_free( n->pkt );
271             }
272             free_node( n );
273             changed = 1;
274         }
275         else
276             nl = n;
277     }
278     return changed;
279 }
280
281 void
282 remove_kbnode( KBNODE *root, KBNODE node )
283 {
284     KBNODE n, nl;
285
286     for( n = *root, nl=NULL; n; n = nl->next ) {
287         if( n == node ) {
288             if( n == *root )
289                 *root = nl = n->next;
290             else
291                 nl->next = n->next;
292             if( !is_cloned_kbnode(n) ) {
293                 free_packet( n->pkt );
294                 gcry_free( n->pkt );
295             }
296             free_node( n );
297         }
298         else
299             nl = n;
300     }
301 }
302
303
304 /****************
305  * Move NODE behind right after WHERE or to the beginning if WHERE is NULL.
306  */
307 void
308 move_kbnode( KBNODE *root, KBNODE node, KBNODE where )
309 {
310     KBNODE tmp, prev;
311
312     if( !root || !*root || !node )
313         return;  /* sanity check */
314     for( prev = *root; prev && prev->next != node; prev = prev->next )
315         ;
316     if( !prev )
317         return; /* node is not in the list */
318
319     if( !where ) {  /* move node before root */
320         if( node == *root ) /* move to itself */
321             return;
322         prev->next = node->next;
323         node->next = *root;
324         *root = node;
325         return;
326     }
327     /* move it after where */
328     if( node == where )
329         return;
330     tmp = node->next;
331     node->next = where->next;
332     where->next = node;
333     prev->next = tmp;
334 }
335
336
337
338
339 void
340 dump_kbnode( KBNODE node )
341 {
342     for(; node; node = node->next ) {
343         const char *s;
344         switch( node->pkt->pkttype ) {
345           case 0:               s="empty"; break;
346           case PKT_PUBLIC_KEY:  s="public-key"; break;
347           case PKT_SECRET_KEY:  s="secret-key"; break;
348           case PKT_SECRET_SUBKEY: s= "secret-subkey"; break;
349           case PKT_PUBKEY_ENC:  s="public-enc"; break;
350           case PKT_SIGNATURE:   s="signature"; break;
351           case PKT_ONEPASS_SIG: s="onepass-sig"; break;
352           case PKT_USER_ID:     s="user-id"; break;
353           case PKT_PUBLIC_SUBKEY: s="public-subkey"; break;
354           case PKT_COMMENT:     s="comment"; break;
355           case PKT_RING_TRUST:  s="trust"; break;
356           case PKT_PLAINTEXT:   s="plaintext"; break;
357           case PKT_COMPRESSED:  s="compressed"; break;
358           case PKT_ENCRYPTED:   s="encrypted"; 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             fputs("  \"", stderr);
365             print_string( stderr, node->pkt->pkt.user_id->name,
366                                   node->pkt->pkt.user_id->len, 0 );
367             fputs("\"\n", stderr);
368         }
369         else if( node->pkt->pkttype == PKT_SIGNATURE ) {
370             fprintf(stderr, "  class=%02x keyid=%08lX\n",
371                    node->pkt->pkt.signature->sig_class,
372                    (ulong)node->pkt->pkt.signature->keyid[1] );
373         }
374         else if( node->pkt->pkttype == PKT_PUBLIC_KEY
375                  || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
376             fprintf(stderr, "  keyid=%08lX\n", (ulong)
377                   keyid_from_pk( node->pkt->pkt.public_key, NULL ));
378         }
379         else
380             fputs("\n", stderr);
381     }
382 }
383