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