new release
[gnupg.git] / g10 / free-packet.c
1 /* free-packet.c - cleanup stuff for packets
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
27 #include "packet.h"
28 #include "iobuf.h"
29 #include "mpi.h"
30 #include "util.h"
31 #include "cipher.h"
32 #include "memory.h"
33
34 void
35 free_symkey_enc( PKT_symkey_enc *enc )
36 {
37     m_free(enc);
38 }
39
40 void
41 free_pubkey_enc( PKT_pubkey_enc *enc )
42 {
43     if( is_ELGAMAL(enc->pubkey_algo) ) {
44         mpi_free( enc->d.elg.a );
45         mpi_free( enc->d.elg.b );
46     }
47     else if( is_RSA(enc->pubkey_algo) )
48         mpi_free( enc->d.rsa.rsa_integer );
49     m_free(enc);
50 }
51
52 void
53 free_seckey_enc( PKT_signature *sig )
54 {
55     if( is_ELGAMAL(sig->pubkey_algo) ) {
56         mpi_free( sig->d.elg.a );
57         mpi_free( sig->d.elg.b );
58     }
59     else if( sig->pubkey_algo == PUBKEY_ALGO_DSA ) {
60         mpi_free( sig->d.dsa.r );
61         mpi_free( sig->d.dsa.s );
62     }
63     else if( is_RSA(sig->pubkey_algo) )
64         mpi_free( sig->d.rsa.rsa_integer );
65     m_free(sig->hashed_data);
66     m_free(sig->unhashed_data);
67     m_free(sig);
68 }
69
70
71
72 void
73 release_public_cert_parts( PKT_public_cert *cert )
74 {
75     if( is_ELGAMAL(cert->pubkey_algo) ) {
76         mpi_free( cert->d.elg.p ); cert->d.elg.p = NULL;
77         mpi_free( cert->d.elg.g ); cert->d.elg.g = NULL;
78         mpi_free( cert->d.elg.y ); cert->d.elg.y = NULL;
79     }
80     else if( cert->pubkey_algo == PUBKEY_ALGO_DSA ) {
81         mpi_free( cert->d.dsa.p ); cert->d.dsa.p = NULL;
82         mpi_free( cert->d.dsa.q ); cert->d.dsa.q = NULL;
83         mpi_free( cert->d.dsa.g ); cert->d.dsa.g = NULL;
84         mpi_free( cert->d.dsa.y ); cert->d.dsa.y = NULL;
85     }
86     else if( is_RSA(cert->pubkey_algo) ) {
87         mpi_free( cert->d.rsa.n ); cert->d.rsa.n = NULL;
88         mpi_free( cert->d.rsa.e ); cert->d.rsa.e = NULL;
89     }
90 }
91
92 void
93 free_public_cert( PKT_public_cert *cert )
94 {
95     release_public_cert_parts( cert );
96     m_free(cert);
97 }
98
99 PKT_public_cert *
100 copy_public_cert( PKT_public_cert *d, PKT_public_cert *s )
101 {
102     if( !d )
103         d = m_alloc(sizeof *d);
104     memcpy( d, s, sizeof *d );
105     if( is_ELGAMAL(s->pubkey_algo) ) {
106         d->d.elg.p = mpi_copy( s->d.elg.p );
107         d->d.elg.g = mpi_copy( s->d.elg.g );
108         d->d.elg.y = mpi_copy( s->d.elg.y );
109     }
110     else if( s->pubkey_algo == PUBKEY_ALGO_DSA ) {
111         d->d.dsa.p = mpi_copy( s->d.dsa.p );
112         d->d.dsa.q = mpi_copy( s->d.dsa.q );
113         d->d.dsa.g = mpi_copy( s->d.dsa.g );
114         d->d.dsa.y = mpi_copy( s->d.dsa.y );
115     }
116     else if( is_RSA(s->pubkey_algo) ) {
117         d->d.rsa.n = mpi_copy( s->d.rsa.n );
118         d->d.rsa.e = mpi_copy( s->d.rsa.e );
119     }
120     return d;
121 }
122
123 void
124 release_secret_cert_parts( PKT_secret_cert *cert )
125 {
126     if( is_ELGAMAL(cert->pubkey_algo) ) {
127         mpi_free( cert->d.elg.p ); cert->d.elg.p = NULL;
128         mpi_free( cert->d.elg.g ); cert->d.elg.g = NULL;
129         mpi_free( cert->d.elg.y ); cert->d.elg.y = NULL;
130         mpi_free( cert->d.elg.x ); cert->d.elg.x = NULL;
131     }
132     else if( cert->pubkey_algo == PUBKEY_ALGO_DSA ) {
133         mpi_free( cert->d.dsa.p ); cert->d.dsa.p = NULL;
134         mpi_free( cert->d.dsa.q ); cert->d.dsa.q = NULL;
135         mpi_free( cert->d.dsa.g ); cert->d.dsa.g = NULL;
136         mpi_free( cert->d.dsa.y ); cert->d.dsa.y = NULL;
137         mpi_free( cert->d.dsa.x ); cert->d.dsa.x = NULL;
138     }
139     else if( is_RSA(cert->pubkey_algo) ) {
140         mpi_free( cert->d.rsa.n ); cert->d.rsa.n = NULL;
141         mpi_free( cert->d.rsa.e ); cert->d.rsa.e = NULL;
142         mpi_free( cert->d.rsa.d ); cert->d.rsa.d = NULL;
143         mpi_free( cert->d.rsa.p ); cert->d.rsa.p = NULL;
144         mpi_free( cert->d.rsa.q ); cert->d.rsa.q = NULL;
145         mpi_free( cert->d.rsa.u ); cert->d.rsa.u = NULL;
146     }
147 }
148
149 void
150 free_secret_cert( PKT_secret_cert *cert )
151 {
152     release_secret_cert_parts( cert );
153     m_free(cert);
154 }
155
156 PKT_secret_cert *
157 copy_secret_cert( PKT_secret_cert *d, PKT_secret_cert *s )
158 {
159     if( !d )
160         d = m_alloc(sizeof *d);
161     memcpy( d, s, sizeof *d );
162     if( is_ELGAMAL(s->pubkey_algo) ) {
163         d->d.elg.p = mpi_copy( s->d.elg.p );
164         d->d.elg.g = mpi_copy( s->d.elg.g );
165         d->d.elg.y = mpi_copy( s->d.elg.y );
166         d->d.elg.x = mpi_copy( s->d.elg.x );
167     }
168     else if( s->pubkey_algo == PUBKEY_ALGO_DSA ) {
169         d->d.dsa.p = mpi_copy( s->d.dsa.p );
170         d->d.dsa.q = mpi_copy( s->d.dsa.q );
171         d->d.dsa.g = mpi_copy( s->d.dsa.g );
172         d->d.dsa.y = mpi_copy( s->d.dsa.y );
173         d->d.dsa.x = mpi_copy( s->d.dsa.x );
174     }
175     else if( is_RSA(s->pubkey_algo) ) {
176         d->d.rsa.n = mpi_copy( s->d.rsa.n );
177         d->d.rsa.e = mpi_copy( s->d.rsa.e );
178         d->d.rsa.d = mpi_copy( s->d.rsa.d );
179         d->d.rsa.p = mpi_copy( s->d.rsa.p );
180         d->d.rsa.q = mpi_copy( s->d.rsa.q );
181         d->d.rsa.u = mpi_copy( s->d.rsa.u );
182     }
183     return d;
184 }
185
186 void
187 free_comment( PKT_comment *rem )
188 {
189     m_free(rem);
190 }
191
192 void
193 free_user_id( PKT_user_id *uid )
194 {
195     m_free(uid);
196 }
197
198 void
199 free_compressed( PKT_compressed *zd )
200 {
201     if( zd->buf ) { /* have to skip some bytes */
202         /* don't have any information about the length, so
203          * we assume this is the last packet */
204         while( iobuf_get(zd->buf) != -1 )
205             ;
206     }
207     m_free(zd);
208 }
209
210 void
211 free_encrypted( PKT_encrypted *ed )
212 {
213     if( ed->buf ) { /* have to skip some bytes */
214         if( iobuf_in_block_mode(ed->buf) ) {
215             while( iobuf_get(ed->buf) != -1 )
216                 ;
217             iobuf_set_block_mode(ed->buf, 0);
218         }
219         else {
220             for( ; ed->len; ed->len-- ) /* skip the packet */
221                 iobuf_get(ed->buf);
222         }
223     }
224     m_free(ed);
225 }
226
227
228 void
229 free_plaintext( PKT_plaintext *pt )
230 {
231     if( pt->buf ) { /* have to skip some bytes */
232         if( iobuf_in_block_mode(pt->buf) ) {
233             while( iobuf_get(pt->buf) != -1 )
234                 ;
235             iobuf_set_block_mode(pt->buf, 0);
236         }
237         else {
238             for( ; pt->len; pt->len-- ) /* skip the packet */
239                 iobuf_get(pt->buf);
240         }
241     }
242     m_free(pt);
243 }
244
245 /****************
246  * Free the packet in pkt.
247  */
248 void
249 free_packet( PACKET *pkt )
250 {
251     if( !pkt || !pkt->pkt.generic )
252         return;
253
254     if( DBG_MEMORY )
255         log_debug("free_packet() type=%d\n", pkt->pkttype );
256
257     switch( pkt->pkttype ) {
258       case PKT_SIGNATURE:
259         free_seckey_enc( pkt->pkt.signature );
260         break;
261       case PKT_PUBKEY_ENC:
262         free_pubkey_enc( pkt->pkt.pubkey_enc );
263         break;
264       case PKT_SYMKEY_ENC:
265         free_symkey_enc( pkt->pkt.symkey_enc );
266         break;
267       case PKT_PUBLIC_CERT:
268         free_public_cert( pkt->pkt.public_cert );
269         break;
270       case PKT_SECRET_CERT:
271         free_secret_cert( pkt->pkt.secret_cert );
272         break;
273       case PKT_COMMENT:
274         free_comment( pkt->pkt.comment );
275         break;
276       case PKT_USER_ID:
277         free_user_id( pkt->pkt.user_id );
278         break;
279       case PKT_COMPRESSED:
280         free_compressed( pkt->pkt.compressed);
281         break;
282       case PKT_ENCRYPTED:
283         free_encrypted( pkt->pkt.encrypted );
284         break;
285       case PKT_PLAINTEXT:
286         free_plaintext( pkt->pkt.plaintext );
287         break;
288       default:
289         m_free( pkt->pkt.generic );
290         break;
291     }
292     pkt->pkt.generic = NULL;
293 }
294
295 /****************
296  * Returns 0 if they match.
297  */
298 int
299 cmp_public_certs( PKT_public_cert *a, PKT_public_cert *b )
300 {
301     if( a->timestamp != b->timestamp )
302         return -1;
303     if( a->valid_days != b->valid_days )
304         return -1;
305     if( a->pubkey_algo != b->pubkey_algo )
306         return -1;
307
308     if( is_ELGAMAL(a->pubkey_algo) ) {
309         if( mpi_cmp( a->d.elg.p , b->d.elg.p ) )
310             return -1;
311         if( mpi_cmp( a->d.elg.g , b->d.elg.g ) )
312             return -1;
313         if( mpi_cmp( a->d.elg.y , b->d.elg.y ) )
314             return -1;
315     }
316     else if( a->pubkey_algo == PUBKEY_ALGO_DSA ) {
317         if( mpi_cmp( a->d.dsa.p , b->d.dsa.p ) )
318             return -1;
319         if( mpi_cmp( a->d.dsa.q , b->d.dsa.q ) )
320             return -1;
321         if( mpi_cmp( a->d.dsa.g , b->d.dsa.g ) )
322             return -1;
323         if( mpi_cmp( a->d.dsa.y , b->d.dsa.y ) )
324             return -1;
325     }
326     else if( is_RSA(a->pubkey_algo) ) {
327         if( mpi_cmp( a->d.rsa.n , b->d.rsa.n ) )
328             return -1;
329         if( mpi_cmp( a->d.rsa.e , b->d.rsa.e ) )
330             return -1;
331     }
332
333     return 0;
334 }
335
336 /****************
337  * Returns 0 if they match.
338  */
339 int
340 cmp_public_secret_cert( PKT_public_cert *pkc, PKT_secret_cert *skc )
341 {
342     if( pkc->timestamp != skc->timestamp )
343         return -1;
344     if( pkc->valid_days != skc->valid_days )
345         return -1;
346     if( pkc->pubkey_algo != skc->pubkey_algo )
347         return -1;
348
349     if( is_ELGAMAL(pkc->pubkey_algo) ) {
350         if( mpi_cmp( pkc->d.elg.p , skc->d.elg.p ) )
351             return -1;
352         if( mpi_cmp( pkc->d.elg.g , skc->d.elg.g ) )
353             return -1;
354         if( mpi_cmp( pkc->d.elg.y , skc->d.elg.y ) )
355             return -1;
356     }
357     else if( pkc->pubkey_algo == PUBKEY_ALGO_DSA ) {
358         if( mpi_cmp( pkc->d.dsa.p , skc->d.dsa.p ) )
359             return -1;
360         if( mpi_cmp( pkc->d.dsa.q , skc->d.dsa.q ) )
361             return -1;
362         if( mpi_cmp( pkc->d.dsa.g , skc->d.dsa.g ) )
363             return -1;
364         if( mpi_cmp( pkc->d.dsa.y , skc->d.dsa.y ) )
365             return -1;
366     }
367     else if( is_RSA(pkc->pubkey_algo) ) {
368         if( mpi_cmp( pkc->d.rsa.n , skc->d.rsa.n ) )
369             return -1;
370         if( mpi_cmp( pkc->d.rsa.e , skc->d.rsa.e ) )
371             return -1;
372     }
373
374     return 0;
375 }
376
377 int
378 cmp_user_ids( PKT_user_id *a, PKT_user_id *b )
379 {
380     int res;
381
382     res = a->len - b->len;
383     if( !res )
384         res = memcmp( a->name, b->name, a->len );
385     return res;
386 }
387
388