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