trunk/Gnupg/kbnode.c

/* kbnode.c -  keyblock node utility functions
 * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
 *
 * This file is part of GnuPG.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <malloc.h>
#include <sys/types.h>

#include "openpgp.h"

#define is_deleted_kbnode(a)  ((a)->private_flag & 1)
#define is_cloned_kbnode(a)   ((a)->private_flag & 2)


static gpg_kbnode_t
alloc_node( void )
{
    gpg_kbnode_t n;
    
    n = malloc( sizeof *n );
    n->next = NULL;
    n->pkt = NULL;
    n->flag = 0;
    n->private_flag=0;
    n->recno = 0;
    return n;
}

static void
free_node( gpg_kbnode_t n )
{
    if( n ) {      
        free( n );
    }
}


gpg_kbnode_t
gpg_new_kbnode( PACKET *pkt )
{
    gpg_kbnode_t n = alloc_node();
    n->pkt = pkt;
    return n;
}


gpg_kbnode_t
gpg_clone_kbnode( gpg_kbnode_t node )
{
    gpg_kbnode_t n = alloc_node();

    n->pkt = node->pkt;
    n->private_flag = node->private_flag | 2; /* mark cloned */
    return n;
}


void
gpg_release_kbnode( gpg_kbnode_t n )
{
    gpg_kbnode_t n2;

    while( n ) {
        n2 = n->next;
        if( !is_cloned_kbnode(n) ) {
            gpg_free_packet( n->pkt );
            free( n->pkt );
        }
        free_node( n );
        n = n2;
    }
}


/****************
 * Delete NODE.
 * Note: This only works with walk_kbnode!!
 */
void
gpg_delete_kbnode( gpg_kbnode_t node )
{
    node->private_flag |= 1;
}


/****************
 * Append NODE to ROOT.  ROOT must exist!
 */
void
gpg_add_kbnode( gpg_kbnode_t root, gpg_kbnode_t node )
{
    gpg_kbnode_t n1;

    for(n1=root; n1->next; n1 = n1->next)
        ;
    n1->next = node;
}


/****************
 * Find the previous node (if PKTTYPE = 0) or the previous node
 * with pkttype PKTTYPE in the list starting with ROOT of NODE.
 */
gpg_kbnode_t
gpg_find_prev_kbnode( gpg_kbnode_t root, gpg_kbnode_t node, int pkttype )
{
    gpg_kbnode_t n1;

    for (n1=NULL; root && root != node; root = root->next ) {
        if (!pkttype ||root->pkt->pkttype == pkttype)
            n1 = root;
    }
    return n1;
}

/****************
 * Ditto, but find the next packet.  The behaviour is trivial if
 * PKTTYPE is 0 but if it is specified, the next node with a packet
 * of this type is returned.  The function has some knowledge about
 * the valid ordering of packets: e.g. if the next signature packet
 * is requested, the function will not return one if it encounters
 * a user-id.
 */
gpg_kbnode_t
gpg_find_next_kbnode( gpg_kbnode_t node, int pkttype )
{
    for( node=node->next ; node; node = node->next ) {
        if( !pkttype )
            return node;
        else if( pkttype == PKT_USER_ID 
                 && (   node->pkt->pkttype == PKT_PUBLIC_KEY
                     || node->pkt->pkttype == PKT_SECRET_KEY ) )
            return NULL;
        else if( pkttype == PKT_SIGNATURE
                 && (   node->pkt->pkttype == PKT_USER_ID
                     || node->pkt->pkttype == PKT_PUBLIC_KEY
                     || node->pkt->pkttype == PKT_SECRET_KEY ) )
            return NULL;
        else if( node->pkt->pkttype == pkttype )
            return node;
    }
    return NULL;
}


gpg_kbnode_t
gpg_find_kbnode( gpg_kbnode_t node, int pkttype )
{
    for( ; node; node = node->next ) {
        if( node->pkt->pkttype == pkttype )
            return node;
    }
    return NULL;
}


/****************
 * Walk through a list of kbnodes. This function returns
 * the next kbnode for each call; before using the function the first
 * time, the caller must set CONTEXT to NULL (This has simply the effect
 * to start with ROOT).
 */
gpg_kbnode_t
gpg_walk_kbnode( gpg_kbnode_t root, gpg_kbnode_t *context, int all )
{
    gpg_kbnode_t n;

    do {
        if( !*context ) {
            *context = root;
            n = root;
        }
        else {
            n = (*context)->next;
            *context = n;
        }
    } while( !all && n && is_deleted_kbnode(n) );

    return n;
}

void
gpg_clear_kbnode_flags( gpg_kbnode_t n )
{
    for( ; n; n = n->next ) {
        n->flag = 0;
    }
}


1	/* kbnode.c - keyblock node utility functions
2	* Copyright (C) 1998, 1999, 2000, 2001 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 <stdio.h>
22	#include <string.h>
23	#include <assert.h>
24	#include <malloc.h>
25	#include <sys/types.h>
26
27	#include "openpgp.h"
28
29	#define is_deleted_kbnode(a) ((a)->private_flag & 1)
30	#define is_cloned_kbnode(a) ((a)->private_flag & 2)
31
32
33	static gpg_kbnode_t
34	alloc_node( void )
35	{
36	gpg_kbnode_t n;
37
38	n = malloc( sizeof *n );
39	n->next = NULL;
40	n->pkt = NULL;
41	n->flag = 0;
42	n->private_flag=0;
43	n->recno = 0;
44	return n;
45	}
46
47	static void
48	free_node( gpg_kbnode_t n )
49	{
50	if( n ) {
51	free( n );
52	}
53	}
54
55
56
57	gpg_kbnode_t
58	gpg_new_kbnode( PACKET *pkt )
59	{
60	gpg_kbnode_t n = alloc_node();
61	n->pkt = pkt;
62	return n;
63	}
64
65
66	gpg_kbnode_t
67	gpg_clone_kbnode( gpg_kbnode_t node )
68	{
69	gpg_kbnode_t n = alloc_node();
70
71	n->pkt = node->pkt;
72	n->private_flag = node->private_flag \| 2; /* mark cloned */
73	return n;
74	}
75
76
77	void
78	gpg_release_kbnode( gpg_kbnode_t n )
79	{
80	gpg_kbnode_t n2;
81
82	while( n ) {
83	n2 = n->next;
84	if( !is_cloned_kbnode(n) ) {
85	gpg_free_packet( n->pkt );
86	free( n->pkt );
87	}
88	free_node( n );
89	n = n2;
90	}
91	}
92
93
94	/****************
95	* Delete NODE.
96	* Note: This only works with walk_kbnode!!
97	*/
98	void
99	gpg_delete_kbnode( gpg_kbnode_t node )
100	{
101	node->private_flag \|= 1;
102	}
103
104
105
106	/****************
107	* Append NODE to ROOT. ROOT must exist!
108	*/
109	void
110	gpg_add_kbnode( gpg_kbnode_t root, gpg_kbnode_t node )
111	{
112	gpg_kbnode_t n1;
113
114	for(n1=root; n1->next; n1 = n1->next)
115	;
116	n1->next = node;
117	}
118
119
120	/****************
121	* Find the previous node (if PKTTYPE = 0) or the previous node
122	* with pkttype PKTTYPE in the list starting with ROOT of NODE.
123	*/
124	gpg_kbnode_t
125	gpg_find_prev_kbnode( gpg_kbnode_t root, gpg_kbnode_t node, int pkttype )
126	{
127	gpg_kbnode_t n1;
128
129	for (n1=NULL; root && root != node; root = root->next ) {
130	if (!pkttype \|\|root->pkt->pkttype == pkttype)
131	n1 = root;
132	}
133	return n1;
134	}
135
136	/****************
137	* Ditto, but find the next packet. The behaviour is trivial if
138	* PKTTYPE is 0 but if it is specified, the next node with a packet
139	* of this type is returned. The function has some knowledge about
140	* the valid ordering of packets: e.g. if the next signature packet
141	* is requested, the function will not return one if it encounters
142	* a user-id.
143	*/
144	gpg_kbnode_t
145	gpg_find_next_kbnode( gpg_kbnode_t node, int pkttype )
146	{
147	for( node=node->next ; node; node = node->next ) {
148	if( !pkttype )
149	return node;
150	else if( pkttype == PKT_USER_ID
151	&& ( node->pkt->pkttype == PKT_PUBLIC_KEY
152	\|\| node->pkt->pkttype == PKT_SECRET_KEY ) )
153	return NULL;
154	else if( pkttype == PKT_SIGNATURE
155	&& ( node->pkt->pkttype == PKT_USER_ID
156	\|\| node->pkt->pkttype == PKT_PUBLIC_KEY
157	\|\| node->pkt->pkttype == PKT_SECRET_KEY ) )
158	return NULL;
159	else if( node->pkt->pkttype == pkttype )
160	return node;
161	}
162	return NULL;
163	}
164
165
166	gpg_kbnode_t
167	gpg_find_kbnode( gpg_kbnode_t node, int pkttype )
168	{
169	for( ; node; node = node->next ) {
170	if( node->pkt->pkttype == pkttype )
171	return node;
172	}
173	return NULL;
174	}
175
176
177
178	/****************
179	* Walk through a list of kbnodes. This function returns
180	* the next kbnode for each call; before using the function the first
181	* time, the caller must set CONTEXT to NULL (This has simply the effect
182	* to start with ROOT).
183	*/
184	gpg_kbnode_t
185	gpg_walk_kbnode( gpg_kbnode_t root, gpg_kbnode_t *context, int all )
186	{
187	gpg_kbnode_t n;
188
189	do {
190	if( !*context ) {
191	*context = root;
192	n = root;
193	}
194	else {
195	n = (*context)->next;
196	*context = n;
197	}
198	} while( !all && n && is_deleted_kbnode(n) );
199
200	return n;
201	}
202
203	void
204	gpg_clear_kbnode_flags( gpg_kbnode_t n )
205	{
206	for( ; n; n = n->next ) {
207	n->flag = 0;
208	}
209	}
210
211
212
213
214