backup
[gnupg.git] / g10 / kbnode.c
1 /* kbnode.c -  keyblock node utility functions
2  *      Copyright (C) 1998 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 #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 KBNODE
36 new_kbnode( PACKET *pkt )
37 {
38     KBNODE n;
39
40     n = unused_nodes;
41     if( n )
42         unused_nodes = n->next;
43     else
44         n = m_alloc( sizeof *n );
45     n->next = NULL;
46     n->pkt = pkt;
47     n->flag = 0;
48     n->private_flag=0;
49     return n;
50 }
51
52
53 KBNODE
54 clone_kbnode( KBNODE node )
55 {
56     KBNODE n;
57
58     n = unused_nodes;
59     if( n )
60         unused_nodes = n->next;
61     else
62         n = m_alloc( sizeof *n );
63     n->next = NULL;
64     n->pkt = node->pkt;
65     n->flag = 0;
66     n->private_flag = node->private_flag | 2; /* mark cloned */
67     return n;
68 }
69
70
71 void
72 release_kbnode( KBNODE n )
73 {
74     KBNODE n2;
75
76     while( n ) {
77         n2 = n->next;
78         if( !(n->private_flag & 2) ) {
79             free_packet( n->pkt );
80             m_free( n->pkt );
81         }
82       #if USE_UNUSED_NODES
83         n->next = unused_nodes;
84         unused_nodes = n;
85       #else
86         m_free( n );
87       #endif
88         n = n2;
89     }
90 }
91
92
93 /****************
94  * Delete NODE from ROOT.  ROOT must exist!
95  * Note: This only works with walk_kbnode!!
96  */
97 void
98 delete_kbnode( KBNODE node )
99 {
100     node->private_flag |= 1;
101 }
102
103
104 /****************
105  * Append NODE to ROOT.  ROOT must exist!
106  */
107 void
108 add_kbnode( KBNODE root, KBNODE node )
109 {
110     KBNODE n1;
111
112     for(n1=root; n1->next; n1 = n1->next)
113         ;
114     n1->next = node;
115 }
116
117 /****************
118  * Insert NODE into the list after root but before a packet which is not of
119  * type PKTTYPE
120  * (only if PKTTYPE != 0)
121  */
122 void
123 insert_kbnode( KBNODE root, KBNODE node, int pkttype )
124 {
125     if( !pkttype ) {
126         node->next = root->next;
127         root->next = node;
128     }
129     else {
130         KBNODE n1;
131
132         for(n1=root; n1->next;  n1 = n1->next)
133             if( pkttype != n1->next->pkt->pkttype ) {
134                 node->next = n1->next;
135                 n1->next = node;
136                 return;
137             }
138         /* no such packet, append */
139         node->next = NULL;
140         n1->next = node;
141     }
142 }
143
144
145 /****************
146  * Find the previous node (if PKTTYPE = 0) or the previous node
147  * with pkttype PKTTYPE in the list starting with ROOT of NODE.
148  */
149 KBNODE
150 find_prev_kbnode( KBNODE root, KBNODE node, int pkttype )
151 {
152     KBNODE n1;
153
154     for(n1=NULL ; root && root != node; root = root->next )
155         if( !pkttype || root->pkt->pkttype == pkttype )
156             n1 = root;
157     return n1;
158 }
159
160 /****************
161  * Ditto, but find the next packet.  The behaviour is trivial if
162  * PKTTYPE is 0 but if it is specified, the next node with a packet
163  * of this type is returned.  The function has some knowledge about
164  * the valid ordering of packets: e.g. if the next signature packet
165  * is requested, the function will not return one if it encounters
166  * a user-id.
167  */
168 KBNODE
169 find_next_kbnode( KBNODE node, int pkttype )
170 {
171     for( node=node->next ; node; node = node->next ) {
172         if( !pkttype )
173             return node;
174         else if( pkttype == PKT_USER_ID
175                  && (   node->pkt->pkttype == PKT_PUBLIC_KEY
176                      || node->pkt->pkttype == PKT_SECRET_KEY ) )
177             return NULL;
178         else if( pkttype == PKT_SIGNATURE
179                  && (   node->pkt->pkttype == PKT_USER_ID
180                      || node->pkt->pkttype == PKT_PUBLIC_KEY
181                      || node->pkt->pkttype == PKT_SECRET_KEY ) )
182             return NULL;
183         else if( node->pkt->pkttype == pkttype )
184             return node;
185     }
186     return NULL;
187 }
188
189
190 KBNODE
191 find_kbnode( KBNODE node, int pkttype )
192 {
193     for( ; node; node = node->next ) {
194         if( node->pkt->pkttype == pkttype )
195             return node;
196     }
197     return NULL;
198 }
199
200
201
202 /****************
203  * Walk through a list of kbnodes. This function returns
204  * the next kbnode for each call; before using the function the first
205  * time, the caller must set CONTEXT to NULL (This has simply the effect
206  * to start with ROOT).
207  */
208 KBNODE
209 walk_kbnode( KBNODE root, KBNODE *context, int all )
210 {
211     KBNODE n;
212
213     do {
214         if( !*context ) {
215             *context = root;
216             n = root;
217         }
218         else {
219             n = (*context)->next;
220             *context = n;
221         }
222     } while( !all && n && (n->private_flag & 1) );
223
224     return n;
225 }
226
227 void
228 clear_kbnode_flags( KBNODE n )
229 {
230     for( ; n; n = n->next ) {
231         n->flag = 0;
232     }
233 }
234
235
236 /****************
237  * Commit changes made to the kblist at ROOT. Note that ROOT my change,
238  * and it is therefore passed by reference.
239  * The function has the effect of removing all nodes marked as deleted.
240  * returns true if any node has been changed
241  */
242 int
243 commit_kbnode( KBNODE *root )
244 {
245     KBNODE n, nl;
246     int changed = 0;
247
248     for( n = *root, nl=NULL; n; n = nl->next ) {
249         if( (n->private_flag & 1) ) {
250             if( n == *root )
251                 *root = nl = n->next;
252             else
253                 nl->next = n->next;
254             if( !(n->private_flag & 2) ) {
255                 free_packet( n->pkt );
256                 m_free( n->pkt );
257             }
258           #if USE_UNUSED_NODES
259             n->next = unused_nodes;
260             unused_nodes = n;
261           #else
262             m_free( n );
263           #endif
264             changed = 1;
265         }
266         else
267             nl = n;
268     }
269     return changed;
270 }
271
272
273 void
274 dump_kbnode( KBNODE node )
275 {
276     for(; node; node = node->next ) {
277         const char *s;
278         switch( node->pkt->pkttype ) {
279           case 0:               s="empty"; break;
280           case PKT_PUBLIC_KEY:  s="public-key"; break;
281           case PKT_SECRET_KEY:  s="secret-key"; break;
282           case PKT_SECRET_SUBKEY: s= "secret-subkey"; break;
283           case PKT_PUBKEY_ENC:  s="public-enc"; break;
284           case PKT_SIGNATURE:   s="signature"; break;
285           case PKT_ONEPASS_SIG: s="onepass-sig"; break;
286           case PKT_USER_ID:     s="user-id"; break;
287           case PKT_PUBLIC_SUBKEY: s="public-subkey"; break;
288           case PKT_COMMENT:     s="comment"; break;
289           case PKT_RING_TRUST:  s="trust"; break;
290           case PKT_PLAINTEXT:   s="plaintext"; break;
291           case PKT_COMPRESSED:  s="compressed"; break;
292           case PKT_ENCRYPTED:   s="encrypted"; break;
293           default:              s="unknown"; break;
294         }
295         fprintf(stderr, "node %p %02x/%02x type=%s",
296                 node, node->flag, node->private_flag, s);
297         if( node->pkt->pkttype == PKT_USER_ID ) {
298             fputs("  \"", stderr);
299             print_string( stderr, node->pkt->pkt.user_id->name,
300                                   node->pkt->pkt.user_id->len, 0 );
301             fputs("\"\n", stderr);
302         }
303         else if( node->pkt->pkttype == PKT_SIGNATURE ) {
304             fprintf(stderr, "  keyid=%08lX\n",
305                    (ulong)node->pkt->pkt.signature->keyid[1] );
306         }
307         else if( node->pkt->pkttype == PKT_PUBLIC_KEY
308                  || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
309             fprintf(stderr, "  keyid=%08lX\n", (ulong)
310                   keyid_from_pk( node->pkt->pkt.public_key, NULL ));
311         }
312         else
313             fputs("\n", stderr);
314     }
315 }
316