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