3883f877a2edb177517fa1c4402dff16d77ae073
[gnupg.git] / g10 / free-packet.c
1 /* free-packet.c - cleanup stuff for packets
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2005, 2010  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "gpg.h"
27 #include "util.h"
28 #include "packet.h"
29 #include "../common/iobuf.h"
30 #include "options.h"
31
32
33 /* This is mpi_copy with a fix for opaque MPIs which store a NULL
34    pointer.  This will also be fixed in Libggcrypt 1.7.0.  */
35 static gcry_mpi_t
36 my_mpi_copy (gcry_mpi_t a)
37 {
38   if (a
39       && gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE)
40       && !gcry_mpi_get_opaque (a, NULL))
41     return NULL;
42
43   return gcry_mpi_copy (a);
44 }
45
46
47 void
48 free_symkey_enc( PKT_symkey_enc *enc )
49 {
50     xfree(enc);
51 }
52
53 void
54 free_pubkey_enc( PKT_pubkey_enc *enc )
55 {
56     int n, i;
57     n = pubkey_get_nenc( enc->pubkey_algo );
58     if( !n )
59         mpi_release(enc->data[0]);
60     for(i=0; i < n; i++ )
61         mpi_release( enc->data[i] );
62     xfree(enc);
63 }
64
65 void
66 free_seckey_enc( PKT_signature *sig )
67 {
68   int n, i;
69
70   n = pubkey_get_nsig( sig->pubkey_algo );
71   if( !n )
72     mpi_release(sig->data[0]);
73   for(i=0; i < n; i++ )
74     mpi_release( sig->data[i] );
75
76   xfree(sig->revkey);
77   xfree(sig->hashed);
78   xfree(sig->unhashed);
79
80   if (sig->pka_info)
81     {
82       xfree (sig->pka_info->uri);
83       xfree (sig->pka_info);
84     }
85   xfree (sig->signers_uid);
86
87   xfree(sig);
88 }
89
90
91 void
92 release_public_key_parts (PKT_public_key *pk)
93 {
94   int n, i;
95
96   if (pk->seckey_info)
97     n = pubkey_get_nskey (pk->pubkey_algo);
98   else
99     n = pubkey_get_npkey (pk->pubkey_algo);
100   if (!n)
101     mpi_release (pk->pkey[0]);
102   for (i=0; i < n; i++ )
103     {
104       mpi_release (pk->pkey[i]);
105       pk->pkey[i] = NULL;
106     }
107   if (pk->seckey_info)
108     {
109       xfree (pk->seckey_info);
110       pk->seckey_info = NULL;
111     }
112   if (pk->prefs)
113     {
114       xfree (pk->prefs);
115       pk->prefs = NULL;
116     }
117   if (pk->user_id)
118     {
119       free_user_id (pk->user_id);
120       pk->user_id = NULL;
121     }
122   if (pk->revkey)
123     {
124       xfree(pk->revkey);
125       pk->revkey=NULL;
126       pk->numrevkeys=0;
127     }
128   if (pk->serialno)
129     {
130       xfree (pk->serialno);
131       pk->serialno = NULL;
132     }
133 }
134
135
136 /* Free an allocated public key structure including all parts.
137    Passing NULL is allowed.  */
138 void
139 free_public_key (PKT_public_key *pk)
140 {
141   if (pk)
142     {
143       release_public_key_parts (pk);
144       xfree(pk);
145     }
146 }
147
148
149 static subpktarea_t *
150 cp_subpktarea (subpktarea_t *s )
151 {
152     subpktarea_t *d;
153
154     if( !s )
155         return NULL;
156     d = xmalloc (sizeof (*d) + s->size - 1 );
157     d->size = s->size;
158     d->len = s->len;
159     memcpy (d->data, s->data, s->len);
160     return d;
161 }
162
163 /*
164  * Return a copy of the preferences
165  */
166 prefitem_t *
167 copy_prefs (const prefitem_t *prefs)
168 {
169     size_t n;
170     prefitem_t *new;
171
172     if (!prefs)
173         return NULL;
174
175     for (n=0; prefs[n].type; n++)
176         ;
177     new = xmalloc ( sizeof (*new) * (n+1));
178     for (n=0; prefs[n].type; n++) {
179         new[n].type = prefs[n].type;
180         new[n].value = prefs[n].value;
181     }
182     new[n].type = PREFTYPE_NONE;
183     new[n].value = 0;
184
185     return new;
186 }
187
188
189 /* Copy the public key S to D.  If D is NULL allocate a new public key
190    structure.  If S has seckret key infos, only the public stuff is
191    copied.  */
192 PKT_public_key *
193 copy_public_key (PKT_public_key *d, PKT_public_key *s)
194 {
195   int n, i;
196
197   if (!d)
198     d = xmalloc (sizeof *d);
199   memcpy (d, s, sizeof *d);
200   d->seckey_info = NULL;
201   d->user_id = scopy_user_id (s->user_id);
202   d->prefs = copy_prefs (s->prefs);
203
204   n = pubkey_get_npkey (s->pubkey_algo);
205   i = 0;
206   if (!n)
207     d->pkey[i++] = my_mpi_copy (s->pkey[0]);
208   else
209     {
210       for (; i < n; i++ )
211         d->pkey[i] = my_mpi_copy (s->pkey[i]);
212     }
213   for (; i < PUBKEY_MAX_NSKEY; i++)
214     d->pkey[i] = NULL;
215
216   if (!s->revkey && s->numrevkeys)
217     BUG();
218   if (s->numrevkeys)
219     {
220       d->revkey = xmalloc(sizeof(struct revocation_key)*s->numrevkeys);
221       memcpy(d->revkey,s->revkey,sizeof(struct revocation_key)*s->numrevkeys);
222     }
223   else
224     d->revkey = NULL;
225   return d;
226 }
227
228
229
230 static pka_info_t *
231 cp_pka_info (const pka_info_t *s)
232 {
233   pka_info_t *d = xmalloc (sizeof *s + strlen (s->email));
234
235   d->valid = s->valid;
236   d->checked = s->checked;
237   d->uri = s->uri? xstrdup (s->uri):NULL;
238   memcpy (d->fpr, s->fpr, sizeof s->fpr);
239   strcpy (d->email, s->email);
240   return d;
241 }
242
243
244 PKT_signature *
245 copy_signature( PKT_signature *d, PKT_signature *s )
246 {
247     int n, i;
248
249     if( !d )
250         d = xmalloc(sizeof *d);
251     memcpy( d, s, sizeof *d );
252     n = pubkey_get_nsig( s->pubkey_algo );
253     if( !n )
254         d->data[0] = my_mpi_copy(s->data[0]);
255     else {
256         for(i=0; i < n; i++ )
257             d->data[i] = my_mpi_copy( s->data[i] );
258     }
259     d->pka_info = s->pka_info? cp_pka_info (s->pka_info) : NULL;
260     d->hashed = cp_subpktarea (s->hashed);
261     d->unhashed = cp_subpktarea (s->unhashed);
262     if (s->signers_uid)
263       d->signers_uid = xstrdup (s->signers_uid);
264     if(s->numrevkeys)
265       {
266         d->revkey=NULL;
267         d->numrevkeys=0;
268         parse_revkeys(d);
269       }
270     return d;
271 }
272
273
274 /*
275  * shallow copy of the user ID
276  */
277 PKT_user_id *
278 scopy_user_id (PKT_user_id *s)
279 {
280     if (s)
281         s->ref++;
282     return s;
283 }
284
285
286
287 void
288 free_comment( PKT_comment *rem )
289 {
290     xfree(rem);
291 }
292
293 void
294 free_attributes(PKT_user_id *uid)
295 {
296   xfree(uid->attribs);
297   xfree(uid->attrib_data);
298
299   uid->attribs=NULL;
300   uid->attrib_data=NULL;
301   uid->attrib_len=0;
302 }
303
304 void
305 free_user_id (PKT_user_id *uid)
306 {
307     log_assert (uid->ref > 0);
308     if (--uid->ref)
309         return;
310
311     free_attributes(uid);
312     xfree (uid->prefs);
313     xfree (uid->namehash);
314     xfree (uid);
315 }
316
317 void
318 free_compressed( PKT_compressed *zd )
319 {
320     if( zd->buf ) { /* have to skip some bytes */
321         /* don't have any information about the length, so
322          * we assume this is the last packet */
323         while( iobuf_read( zd->buf, NULL, 1<<30 ) != -1 )
324             ;
325     }
326     xfree(zd);
327 }
328
329 void
330 free_encrypted( PKT_encrypted *ed )
331 {
332     if( ed->buf ) { /* have to skip some bytes */
333         if( ed->is_partial ) {
334             while( iobuf_read( ed->buf, NULL, 1<<30 ) != -1 )
335                 ;
336         }
337         else {
338            while( ed->len ) { /* skip the packet */
339                int n = iobuf_read( ed->buf, NULL, ed->len );
340                if( n == -1 )
341                    ed->len = 0;
342                else
343                    ed->len -= n;
344            }
345         }
346     }
347     xfree(ed);
348 }
349
350
351 void
352 free_plaintext( PKT_plaintext *pt )
353 {
354     if( pt->buf ) { /* have to skip some bytes */
355         if( pt->is_partial ) {
356             while( iobuf_read( pt->buf, NULL, 1<<30 ) != -1 )
357                 ;
358         }
359         else {
360            while( pt->len ) { /* skip the packet */
361                int n = iobuf_read( pt->buf, NULL, pt->len );
362                if( n == -1 )
363                    pt->len = 0;
364                else
365                    pt->len -= n;
366            }
367         }
368     }
369     xfree(pt);
370 }
371
372 /****************
373  * Free the packet in pkt.
374  */
375 void
376 free_packet( PACKET *pkt )
377 {
378     if( !pkt || !pkt->pkt.generic )
379         return;
380
381     if( DBG_MEMORY )
382         log_debug("free_packet() type=%d\n", pkt->pkttype );
383
384     switch( pkt->pkttype ) {
385       case PKT_SIGNATURE:
386         free_seckey_enc( pkt->pkt.signature );
387         break;
388       case PKT_PUBKEY_ENC:
389         free_pubkey_enc( pkt->pkt.pubkey_enc );
390         break;
391       case PKT_SYMKEY_ENC:
392         free_symkey_enc( pkt->pkt.symkey_enc );
393         break;
394       case PKT_PUBLIC_KEY:
395       case PKT_PUBLIC_SUBKEY:
396       case PKT_SECRET_KEY:
397       case PKT_SECRET_SUBKEY:
398         free_public_key (pkt->pkt.public_key);
399         break;
400       case PKT_COMMENT:
401         free_comment( pkt->pkt.comment );
402         break;
403       case PKT_USER_ID:
404         free_user_id( pkt->pkt.user_id );
405         break;
406       case PKT_COMPRESSED:
407         free_compressed( pkt->pkt.compressed);
408         break;
409       case PKT_ENCRYPTED:
410       case PKT_ENCRYPTED_MDC:
411         free_encrypted( pkt->pkt.encrypted );
412         break;
413       case PKT_PLAINTEXT:
414         free_plaintext( pkt->pkt.plaintext );
415         break;
416       default:
417         xfree( pkt->pkt.generic );
418         break;
419     }
420     pkt->pkt.generic = NULL;
421 }
422
423 /****************
424  * returns 0 if they match.
425  */
426 int
427 cmp_public_keys( PKT_public_key *a, PKT_public_key *b )
428 {
429     int n, i;
430
431     if( a->timestamp != b->timestamp )
432         return -1;
433     if( a->version < 4 && a->expiredate != b->expiredate )
434         return -1;
435     if( a->pubkey_algo != b->pubkey_algo )
436         return -1;
437
438     n = pubkey_get_npkey( b->pubkey_algo );
439     if( !n ) { /* unknown algorithm, rest is in opaque MPI */
440         if( mpi_cmp( a->pkey[0], b->pkey[0] ) )
441             return -1; /* can't compare due to unknown algorithm */
442     } else {
443         for(i=0; i < n; i++ ) {
444             if( mpi_cmp( a->pkey[i], b->pkey[i] ) )
445                 return -1;
446         }
447     }
448
449     return 0;
450 }
451
452
453
454 int
455 cmp_signatures( PKT_signature *a, PKT_signature *b )
456 {
457     int n, i;
458
459     if( a->keyid[0] != b->keyid[0] )
460         return -1;
461     if( a->keyid[1] != b->keyid[1] )
462         return -1;
463     if( a->pubkey_algo != b->pubkey_algo )
464         return -1;
465
466     n = pubkey_get_nsig( a->pubkey_algo );
467     if( !n )
468         return -1; /* can't compare due to unknown algorithm */
469     for(i=0; i < n; i++ ) {
470         if( mpi_cmp( a->data[i] , b->data[i] ) )
471             return -1;
472     }
473     return 0;
474 }
475
476
477 /****************
478  * Returns: true if the user ids do not match
479  */
480 int
481 cmp_user_ids( PKT_user_id *a, PKT_user_id *b )
482 {
483     int res=1;
484
485     if( a == b )
486         return 0;
487
488     if( a->attrib_data && b->attrib_data )
489       {
490         res = a->attrib_len - b->attrib_len;
491         if( !res )
492           res = memcmp( a->attrib_data, b->attrib_data, a->attrib_len );
493       }
494     else if( !a->attrib_data && !b->attrib_data )
495       {
496         res = a->len - b->len;
497         if( !res )
498           res = memcmp( a->name, b->name, a->len );
499       }
500
501     return res;
502 }