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