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
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

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