gpg: Remove all assert.h and s/assert/log_assert/.
[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
86   xfree(sig);
87 }
88
89
90 void
91 release_public_key_parts (PKT_public_key *pk)
92 {
93   int n, i;
94
95   if (pk->seckey_info)
96     n = pubkey_get_nskey (pk->pubkey_algo);
97   else
98     n = pubkey_get_npkey (pk->pubkey_algo);
99   if (!n)
100     mpi_release (pk->pkey[0]);
101   for (i=0; i < n; i++ )
102     {
103       mpi_release (pk->pkey[i]);
104       pk->pkey[i] = NULL;
105     }
106   if (pk->seckey_info)
107     {
108       xfree (pk->seckey_info);
109       pk->seckey_info = NULL;
110     }
111   if (pk->prefs)
112     {
113       xfree (pk->prefs);
114       pk->prefs = NULL;
115     }
116   if (pk->user_id)
117     {
118       free_user_id (pk->user_id);
119       pk->user_id = NULL;
120     }
121   if (pk->revkey)
122     {
123       xfree(pk->revkey);
124       pk->revkey=NULL;
125       pk->numrevkeys=0;
126     }
127   if (pk->serialno)
128     {
129       xfree (pk->serialno);
130       pk->serialno = NULL;
131     }
132 }
133
134
135 /* Free an allocated public key structure including all parts.
136    Passing NULL is allowed.  */
137 void
138 free_public_key (PKT_public_key *pk)
139 {
140   if (pk)
141     {
142       release_public_key_parts (pk);
143       xfree(pk);
144     }
145 }
146
147
148 static subpktarea_t *
149 cp_subpktarea (subpktarea_t *s )
150 {
151     subpktarea_t *d;
152
153     if( !s )
154         return NULL;
155     d = xmalloc (sizeof (*d) + s->size - 1 );
156     d->size = s->size;
157     d->len = s->len;
158     memcpy (d->data, s->data, s->len);
159     return d;
160 }
161
162 /*
163  * Return a copy of the preferences
164  */
165 prefitem_t *
166 copy_prefs (const prefitem_t *prefs)
167 {
168     size_t n;
169     prefitem_t *new;
170
171     if (!prefs)
172         return NULL;
173
174     for (n=0; prefs[n].type; n++)
175         ;
176     new = xmalloc ( sizeof (*new) * (n+1));
177     for (n=0; prefs[n].type; n++) {
178         new[n].type = prefs[n].type;
179         new[n].value = prefs[n].value;
180     }
181     new[n].type = PREFTYPE_NONE;
182     new[n].value = 0;
183
184     return new;
185 }
186
187
188 /* Copy the public key S to D.  If D is NULL allocate a new public key
189    structure.  If S has seckret key infos, only the public stuff is
190    copied.  */
191 PKT_public_key *
192 copy_public_key (PKT_public_key *d, PKT_public_key *s)
193 {
194   int n, i;
195
196   if (!d)
197     d = xmalloc (sizeof *d);
198   memcpy (d, s, sizeof *d);
199   d->seckey_info = NULL;
200   d->user_id = scopy_user_id (s->user_id);
201   d->prefs = copy_prefs (s->prefs);
202
203   n = pubkey_get_npkey (s->pubkey_algo);
204   i = 0;
205   if (!n)
206     d->pkey[i++] = my_mpi_copy (s->pkey[0]);
207   else
208     {
209       for (; i < n; i++ )
210         d->pkey[i] = my_mpi_copy (s->pkey[i]);
211     }
212   for (; i < PUBKEY_MAX_NSKEY; i++)
213     d->pkey[i] = NULL;
214
215   if (!s->revkey && s->numrevkeys)
216     BUG();
217   if (s->numrevkeys)
218     {
219       d->revkey = xmalloc(sizeof(struct revocation_key)*s->numrevkeys);
220       memcpy(d->revkey,s->revkey,sizeof(struct revocation_key)*s->numrevkeys);
221     }
222   else
223     d->revkey = NULL;
224   return d;
225 }
226
227
228
229 static pka_info_t *
230 cp_pka_info (const pka_info_t *s)
231 {
232   pka_info_t *d = xmalloc (sizeof *s + strlen (s->email));
233
234   d->valid = s->valid;
235   d->checked = s->checked;
236   d->uri = s->uri? xstrdup (s->uri):NULL;
237   memcpy (d->fpr, s->fpr, sizeof s->fpr);
238   strcpy (d->email, s->email);
239   return d;
240 }
241
242
243 PKT_signature *
244 copy_signature( PKT_signature *d, PKT_signature *s )
245 {
246     int n, i;
247
248     if( !d )
249         d = xmalloc(sizeof *d);
250     memcpy( d, s, sizeof *d );
251     n = pubkey_get_nsig( s->pubkey_algo );
252     if( !n )
253         d->data[0] = my_mpi_copy(s->data[0]);
254     else {
255         for(i=0; i < n; i++ )
256             d->data[i] = my_mpi_copy( s->data[i] );
257     }
258     d->pka_info = s->pka_info? cp_pka_info (s->pka_info) : NULL;
259     d->hashed = cp_subpktarea (s->hashed);
260     d->unhashed = cp_subpktarea (s->unhashed);
261     if(s->numrevkeys)
262       {
263         d->revkey=NULL;
264         d->numrevkeys=0;
265         parse_revkeys(d);
266       }
267     return d;
268 }
269
270
271 /*
272  * shallow copy of the user ID
273  */
274 PKT_user_id *
275 scopy_user_id (PKT_user_id *s)
276 {
277     if (s)
278         s->ref++;
279     return s;
280 }
281
282
283
284 void
285 free_comment( PKT_comment *rem )
286 {
287     xfree(rem);
288 }
289
290 void
291 free_attributes(PKT_user_id *uid)
292 {
293   xfree(uid->attribs);
294   xfree(uid->attrib_data);
295
296   uid->attribs=NULL;
297   uid->attrib_data=NULL;
298   uid->attrib_len=0;
299 }
300
301 void
302 free_user_id (PKT_user_id *uid)
303 {
304     log_assert (uid->ref > 0);
305     if (--uid->ref)
306         return;
307
308     free_attributes(uid);
309     xfree (uid->prefs);
310     xfree (uid->namehash);
311     xfree (uid);
312 }
313
314 void
315 free_compressed( PKT_compressed *zd )
316 {
317     if( zd->buf ) { /* have to skip some bytes */
318         /* don't have any information about the length, so
319          * we assume this is the last packet */
320         while( iobuf_read( zd->buf, NULL, 1<<30 ) != -1 )
321             ;
322     }
323     xfree(zd);
324 }
325
326 void
327 free_encrypted( PKT_encrypted *ed )
328 {
329     if( ed->buf ) { /* have to skip some bytes */
330         if( ed->is_partial ) {
331             while( iobuf_read( ed->buf, NULL, 1<<30 ) != -1 )
332                 ;
333         }
334         else {
335            while( ed->len ) { /* skip the packet */
336                int n = iobuf_read( ed->buf, NULL, ed->len );
337                if( n == -1 )
338                    ed->len = 0;
339                else
340                    ed->len -= n;
341            }
342         }
343     }
344     xfree(ed);
345 }
346
347
348 void
349 free_plaintext( PKT_plaintext *pt )
350 {
351     if( pt->buf ) { /* have to skip some bytes */
352         if( pt->is_partial ) {
353             while( iobuf_read( pt->buf, NULL, 1<<30 ) != -1 )
354                 ;
355         }
356         else {
357            while( pt->len ) { /* skip the packet */
358                int n = iobuf_read( pt->buf, NULL, pt->len );
359                if( n == -1 )
360                    pt->len = 0;
361                else
362                    pt->len -= n;
363            }
364         }
365     }
366     xfree(pt);
367 }
368
369 /****************
370  * Free the packet in pkt.
371  */
372 void
373 free_packet( PACKET *pkt )
374 {
375     if( !pkt || !pkt->pkt.generic )
376         return;
377
378     if( DBG_MEMORY )
379         log_debug("free_packet() type=%d\n", pkt->pkttype );
380
381     switch( pkt->pkttype ) {
382       case PKT_SIGNATURE:
383         free_seckey_enc( pkt->pkt.signature );
384         break;
385       case PKT_PUBKEY_ENC:
386         free_pubkey_enc( pkt->pkt.pubkey_enc );
387         break;
388       case PKT_SYMKEY_ENC:
389         free_symkey_enc( pkt->pkt.symkey_enc );
390         break;
391       case PKT_PUBLIC_KEY:
392       case PKT_PUBLIC_SUBKEY:
393       case PKT_SECRET_KEY:
394       case PKT_SECRET_SUBKEY:
395         free_public_key (pkt->pkt.public_key);
396         break;
397       case PKT_COMMENT:
398         free_comment( pkt->pkt.comment );
399         break;
400       case PKT_USER_ID:
401         free_user_id( pkt->pkt.user_id );
402         break;
403       case PKT_COMPRESSED:
404         free_compressed( pkt->pkt.compressed);
405         break;
406       case PKT_ENCRYPTED:
407       case PKT_ENCRYPTED_MDC:
408         free_encrypted( pkt->pkt.encrypted );
409         break;
410       case PKT_PLAINTEXT:
411         free_plaintext( pkt->pkt.plaintext );
412         break;
413       default:
414         xfree( pkt->pkt.generic );
415         break;
416     }
417     pkt->pkt.generic = NULL;
418 }
419
420 /****************
421  * returns 0 if they match.
422  */
423 int
424 cmp_public_keys( PKT_public_key *a, PKT_public_key *b )
425 {
426     int n, i;
427
428     if( a->timestamp != b->timestamp )
429         return -1;
430     if( a->version < 4 && a->expiredate != b->expiredate )
431         return -1;
432     if( a->pubkey_algo != b->pubkey_algo )
433         return -1;
434
435     n = pubkey_get_npkey( b->pubkey_algo );
436     if( !n ) { /* unknown algorithm, rest is in opaque MPI */
437         if( mpi_cmp( a->pkey[0], b->pkey[0] ) )
438             return -1; /* can't compare due to unknown algorithm */
439     } else {
440         for(i=0; i < n; i++ ) {
441             if( mpi_cmp( a->pkey[i], b->pkey[i] ) )
442                 return -1;
443         }
444     }
445
446     return 0;
447 }
448
449
450
451 int
452 cmp_signatures( PKT_signature *a, PKT_signature *b )
453 {
454     int n, i;
455
456     if( a->keyid[0] != b->keyid[0] )
457         return -1;
458     if( a->keyid[1] != b->keyid[1] )
459         return -1;
460     if( a->pubkey_algo != b->pubkey_algo )
461         return -1;
462
463     n = pubkey_get_nsig( a->pubkey_algo );
464     if( !n )
465         return -1; /* can't compare due to unknown algorithm */
466     for(i=0; i < n; i++ ) {
467         if( mpi_cmp( a->data[i] , b->data[i] ) )
468             return -1;
469     }
470     return 0;
471 }
472
473
474 /****************
475  * Returns: true if the user ids do not match
476  */
477 int
478 cmp_user_ids( PKT_user_id *a, PKT_user_id *b )
479 {
480     int res=1;
481
482     if( a == b )
483         return 0;
484
485     if( a->attrib_data && b->attrib_data )
486       {
487         res = a->attrib_len - b->attrib_len;
488         if( !res )
489           res = memcmp( a->attrib_data, b->attrib_data, a->attrib_len );
490       }
491     else if( !a->attrib_data && !b->attrib_data )
492       {
493         res = a->len - b->len;
494         if( !res )
495           res = memcmp( a->name, b->name, a->len );
496       }
497
498     return res;
499 }