indent: Re-indent parts of build-packet.c
[gnupg.git] / g10 / build-packet.c
1 /* build-packet.c - assemble packets and write them
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2010, 2011  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 <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26
27 #include "gpg.h"
28 #include "../common/util.h"
29 #include "packet.h"
30 #include "../common/status.h"
31 #include "../common/iobuf.h"
32 #include "../common/i18n.h"
33 #include "options.h"
34 #include "../common/host2net.h"
35
36 static int do_user_id( IOBUF out, int ctb, PKT_user_id *uid );
37 static int do_key (iobuf_t out, int ctb, PKT_public_key *pk);
38 static int do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc );
39 static int do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc );
40 static u32 calc_plaintext( PKT_plaintext *pt );
41 static int do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt );
42 static int do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed );
43 static int do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed );
44 static int do_compressed( IOBUF out, int ctb, PKT_compressed *cd );
45 static int do_signature( IOBUF out, int ctb, PKT_signature *sig );
46 static int do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops );
47
48 static int calc_header_length( u32 len, int new_ctb );
49 static int write_16(IOBUF inp, u16 a);
50 static int write_32(IOBUF inp, u32 a);
51 static int write_header( IOBUF out, int ctb, u32 len );
52 static int write_sign_packet_header( IOBUF out, int ctb, u32 len );
53 static int write_header2( IOBUF out, int ctb, u32 len, int hdrlen );
54 static int write_new_header( IOBUF out, int ctb, u32 len, int hdrlen );
55
56 /* Returns 1 if CTB is a new format ctb and 0 if CTB is an old format
57    ctb.  */
58 static int
59 ctb_new_format_p (int ctb)
60 {
61   /* Bit 7 must always be set.  */
62   log_assert ((ctb & (1 << 7)));
63   /* Bit 6 indicates whether the packet is a new format packet.  */
64   return (ctb & (1 << 6));
65 }
66
67 /* Extract the packet type from a CTB.  */
68 static int
69 ctb_pkttype (int ctb)
70 {
71   if (ctb_new_format_p (ctb))
72     /* Bits 0 through 5 are the packet type.  */
73     return (ctb & ((1 << 6) - 1));
74   else
75     /* Bits 2 through 5 are the packet type.  */
76     return (ctb & ((1 << 6) - 1)) >> 2;
77 }
78
79 /****************
80  * Build a packet and write it to INP
81  * Returns: 0 := okay
82  *         >0 := error
83  * Note: Caller must free the packet
84  */
85 int
86 build_packet( IOBUF out, PACKET *pkt )
87 {
88   int rc = 0;
89   int new_ctb = 0;
90   int ctb, pkttype;
91
92   if (DBG_PACKET)
93     log_debug ("build_packet() type=%d\n", pkt->pkttype);
94   log_assert (pkt->pkt.generic);
95
96   switch ((pkttype = pkt->pkttype))
97     {
98     case PKT_PUBLIC_KEY:
99       if (pkt->pkt.public_key->seckey_info)
100         pkttype = PKT_SECRET_KEY;
101       break;
102     case PKT_PUBLIC_SUBKEY:
103       if (pkt->pkt.public_key->seckey_info)
104         pkttype = PKT_SECRET_SUBKEY;
105       break;
106     case PKT_PLAINTEXT:
107       new_ctb = pkt->pkt.plaintext->new_ctb;
108       break;
109     case PKT_ENCRYPTED:
110     case PKT_ENCRYPTED_MDC:
111       new_ctb = pkt->pkt.encrypted->new_ctb;
112       break;
113     case PKT_COMPRESSED:
114       new_ctb = pkt->pkt.compressed->new_ctb;
115       break;
116     case PKT_USER_ID:
117       if (pkt->pkt.user_id->attrib_data)
118         pkttype = PKT_ATTRIBUTE;
119       break;
120     default:
121       break;
122     }
123
124   if (new_ctb || pkttype > 15) /* new format */
125     ctb = (0xc0 | (pkttype & 0x3f));
126   else
127     ctb = (0x80 | ((pkttype & 15)<<2));
128   switch (pkttype)
129     {
130     case PKT_ATTRIBUTE:
131     case PKT_USER_ID:
132       rc = do_user_id (out, ctb, pkt->pkt.user_id);
133       break;
134     case PKT_OLD_COMMENT:
135     case PKT_COMMENT:
136       /* Ignore these.  Theoretically, this will never be called as we
137        * have no way to output comment packets any longer, but just in
138        * case there is some code path that would end up outputting a
139        * comment that was written before comments were dropped (in the
140        * public key?) this is a no-op.  */
141       break;
142     case PKT_PUBLIC_SUBKEY:
143     case PKT_PUBLIC_KEY:
144     case PKT_SECRET_SUBKEY:
145     case PKT_SECRET_KEY:
146       rc = do_key (out, ctb, pkt->pkt.public_key);
147       break;
148     case PKT_SYMKEY_ENC:
149       rc = do_symkey_enc (out, ctb, pkt->pkt.symkey_enc);
150       break;
151     case PKT_PUBKEY_ENC:
152       rc = do_pubkey_enc (out, ctb, pkt->pkt.pubkey_enc);
153       break;
154     case PKT_PLAINTEXT:
155       rc = do_plaintext (out, ctb, pkt->pkt.plaintext);
156       break;
157     case PKT_ENCRYPTED:
158       rc = do_encrypted (out, ctb, pkt->pkt.encrypted);
159       break;
160     case PKT_ENCRYPTED_MDC:
161       rc = do_encrypted_mdc (out, ctb, pkt->pkt.encrypted);
162       break;
163     case PKT_COMPRESSED:
164       rc = do_compressed (out, ctb, pkt->pkt.compressed);
165       break;
166     case PKT_SIGNATURE:
167       rc = do_signature (out, ctb, pkt->pkt.signature);
168       break;
169     case PKT_ONEPASS_SIG:
170       rc = do_onepass_sig (out, ctb, pkt->pkt.onepass_sig);
171       break;
172     case PKT_RING_TRUST:
173       /* Ignore it (keyring.c does write it directly)  */
174       break;
175     case PKT_MDC:
176       /* We write it directly, so we should never see it here. */
177     default:
178       log_bug ("invalid packet type in build_packet()\n");
179       break;
180     }
181
182   return rc;
183 }
184
185
186 /*
187  * Write the mpi A to OUT.
188  */
189 gpg_error_t
190 gpg_mpi_write (iobuf_t out, gcry_mpi_t a)
191 {
192   int rc;
193
194   if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
195     {
196       unsigned int nbits;
197       const unsigned char *p;
198       unsigned char lenhdr[2];
199
200       /* gcry_log_debugmpi ("a", a); */
201       p = gcry_mpi_get_opaque (a, &nbits);
202       if (p)
203         {
204           /* Strip leading zero bits.  */
205           for (; nbits >= 8 && !*p; p++, nbits -= 8)
206             ;
207           if (nbits >= 8 && !(*p & 0x80))
208             if (--nbits >= 7 && !(*p & 0x40))
209               if (--nbits >= 6 && !(*p & 0x20))
210                 if (--nbits >= 5 && !(*p & 0x10))
211                   if (--nbits >= 4 && !(*p & 0x08))
212                     if (--nbits >= 3 && !(*p & 0x04))
213                       if (--nbits >= 2 && !(*p & 0x02))
214                         if (--nbits >= 1 && !(*p & 0x01))
215                           --nbits;
216         }
217       /* gcry_log_debug ("   [%u bit]\n", nbits); */
218       /* gcry_log_debughex (" ", p, (nbits+7)/8); */
219       lenhdr[0] = nbits >> 8;
220       lenhdr[1] = nbits;
221       rc = iobuf_write (out, lenhdr, 2);
222       if (!rc && p)
223         rc = iobuf_write (out, p, (nbits+7)/8);
224     }
225   else
226     {
227       char buffer[(MAX_EXTERN_MPI_BITS+7)/8+2]; /* 2 is for the mpi length. */
228       size_t nbytes;
229
230       nbytes = DIM(buffer);
231       rc = gcry_mpi_print (GCRYMPI_FMT_PGP, buffer, nbytes, &nbytes, a );
232       if( !rc )
233         rc = iobuf_write( out, buffer, nbytes );
234       else if (gpg_err_code(rc) == GPG_ERR_TOO_SHORT )
235         {
236           log_info ("mpi too large (%u bits)\n", gcry_mpi_get_nbits (a));
237           /* The buffer was too small. We better tell the user about the MPI. */
238           rc = gpg_error (GPG_ERR_TOO_LARGE);
239         }
240     }
241
242   return rc;
243 }
244
245
246 /*
247  * Write an opaque MPI to the output stream without length info.
248  */
249 gpg_error_t
250 gpg_mpi_write_nohdr (iobuf_t out, gcry_mpi_t a)
251 {
252   int rc;
253
254   if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
255     {
256       unsigned int nbits;
257       const void *p;
258
259       p = gcry_mpi_get_opaque (a, &nbits);
260       rc = p ? iobuf_write (out, p, (nbits+7)/8) : 0;
261     }
262   else
263     rc = gpg_error (GPG_ERR_BAD_MPI);
264
265   return rc;
266 }
267
268
269 /* Calculate the length of a packet described by PKT.  */
270 u32
271 calc_packet_length( PACKET *pkt )
272 {
273   u32 n = 0;
274   int new_ctb = 0;
275
276   log_assert (pkt->pkt.generic);
277   switch (pkt->pkttype)
278     {
279     case PKT_PLAINTEXT:
280       n = calc_plaintext (pkt->pkt.plaintext);
281       new_ctb = pkt->pkt.plaintext->new_ctb;
282       break;
283     case PKT_ATTRIBUTE:
284     case PKT_USER_ID:
285     case PKT_COMMENT:
286     case PKT_PUBLIC_KEY:
287     case PKT_SECRET_KEY:
288     case PKT_SYMKEY_ENC:
289     case PKT_PUBKEY_ENC:
290     case PKT_ENCRYPTED:
291     case PKT_SIGNATURE:
292     case PKT_ONEPASS_SIG:
293     case PKT_RING_TRUST:
294     case PKT_COMPRESSED:
295     default:
296       log_bug ("invalid packet type in calc_packet_length()");
297       break;
298     }
299
300   n += calc_header_length (n, new_ctb);
301   return n;
302 }
303
304
305 static gpg_error_t
306 write_fake_data (IOBUF out, gcry_mpi_t a)
307 {
308   unsigned int n;
309   void *p;
310
311   if (!a)
312     return 0;
313   if (!gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
314     return 0; /* e.g. due to generating a key with wrong usage.  */
315   p = gcry_mpi_get_opaque ( a, &n);
316   if (!p)
317     return 0; /* For example due to a read error in
318                  parse-packet.c:read_rest.  */
319   return iobuf_write (out, p, (n+7)/8 );
320 }
321
322
323 /* Serialize the user id (RFC 4880, Section 5.11) or the user
324  * attribute UID (Section 5.12) and write it to OUT.
325  *
326  * CTB is the serialization's CTB.  It specifies the header format and
327  * the packet's type.  The header length must not be set.  */
328 static int
329 do_user_id( IOBUF out, int ctb, PKT_user_id *uid )
330 {
331   int rc;
332
333   log_assert (ctb_pkttype (ctb) == PKT_USER_ID
334               || ctb_pkttype (ctb) == PKT_ATTRIBUTE);
335
336   if (uid->attrib_data)
337     {
338       write_header(out, ctb, uid->attrib_len);
339       rc = iobuf_write( out, uid->attrib_data, uid->attrib_len );
340     }
341   else
342     {
343       write_header2( out, ctb, uid->len, 0 );
344       rc = iobuf_write( out, uid->name, uid->len );
345     }
346   return rc;
347 }
348
349
350 /* Serialize the key (RFC 4880, Section 5.5) described by PK and write
351  * it to OUT.
352  *
353  * This function serializes both primary keys and subkeys with or
354  * without a secret part.
355  *
356  * CTB is the serialization's CTB.  It specifies the header format and
357  * the packet's type.  The header length must not be set.
358  *
359  * PK->VERSION specifies the serialization format.  A value of 0 means
360  * to use the default version.  Currently, only version 4 packets are
361  * supported.
362  */
363 static int
364 do_key (iobuf_t out, int ctb, PKT_public_key *pk)
365 {
366   gpg_error_t err = 0;
367   /* The length of the body is stored in the packet's header, which
368      occurs before the body.  Unfortunately, we don't know the length
369      of the packet's body until we've written all of the data!  To
370      work around this, we first write the data into this temporary
371      buffer, then generate the header, and finally copy the contents
372      of this buffer to OUT.  */
373   iobuf_t a = iobuf_temp();
374   int i, nskey, npkey;
375
376   log_assert (pk->version == 0 || pk->version == 4);
377   log_assert (ctb_pkttype (ctb) == PKT_PUBLIC_KEY
378               || ctb_pkttype (ctb) == PKT_PUBLIC_SUBKEY
379               || ctb_pkttype (ctb) == PKT_SECRET_KEY
380               || ctb_pkttype (ctb) == PKT_SECRET_SUBKEY);
381
382   /* Write the version number - if none is specified, use 4 */
383   if ( !pk->version )
384     iobuf_put ( a, 4 );
385   else
386     iobuf_put ( a, pk->version );
387   write_32 (a, pk->timestamp );
388
389   iobuf_put (a, pk->pubkey_algo );
390
391   /* Get number of secret and public parameters.  They are held in one
392      array: the public ones followed by the secret ones.  */
393   nskey = pubkey_get_nskey (pk->pubkey_algo);
394   npkey = pubkey_get_npkey (pk->pubkey_algo);
395
396   /* If we don't have any public parameters - which is for example the
397      case if we don't know the algorithm used - the parameters are
398      stored as one blob in a faked (opaque) MPI. */
399   if (!npkey)
400     {
401       write_fake_data (a, pk->pkey[0]);
402       goto leave;
403     }
404   log_assert (npkey < nskey);
405
406   for (i=0; i < npkey; i++ )
407     {
408       if (   (pk->pubkey_algo == PUBKEY_ALGO_ECDSA && (i == 0))
409           || (pk->pubkey_algo == PUBKEY_ALGO_EDDSA && (i == 0))
410           || (pk->pubkey_algo == PUBKEY_ALGO_ECDH  && (i == 0 || i == 2)))
411         err = gpg_mpi_write_nohdr (a, pk->pkey[i]);
412       else
413         err = gpg_mpi_write (a, pk->pkey[i]);
414       if (err)
415         goto leave;
416     }
417
418
419   if (pk->seckey_info)
420     {
421       /* This is a secret key packet.  */
422       struct seckey_info *ski = pk->seckey_info;
423
424       /* Build the header for protected (encrypted) secret parameters.  */
425       if (ski->is_protected)
426         {
427           /* OpenPGP protection according to rfc2440. */
428           iobuf_put (a, ski->sha1chk? 0xfe : 0xff);
429           iobuf_put (a, ski->algo);
430           if (ski->s2k.mode >= 1000)
431             {
432               /* These modes are not possible in OpenPGP, we use them
433                  to implement our extensions, 101 can be viewed as a
434                  private/experimental extension (this is not specified
435                  in rfc2440 but the same scheme is used for all other
436                  algorithm identifiers). */
437               iobuf_put (a, 101);
438               iobuf_put (a, ski->s2k.hash_algo);
439               iobuf_write (a, "GNU", 3 );
440               iobuf_put (a, ski->s2k.mode - 1000);
441             }
442           else
443             {
444               iobuf_put (a, ski->s2k.mode);
445               iobuf_put (a, ski->s2k.hash_algo);
446             }
447
448           if (ski->s2k.mode == 1 || ski->s2k.mode == 3)
449             iobuf_write (a, ski->s2k.salt, 8);
450
451           if (ski->s2k.mode == 3)
452             iobuf_put (a, ski->s2k.count);
453
454           /* For our special modes 1001, 1002 we do not need an IV. */
455           if (ski->s2k.mode != 1001 && ski->s2k.mode != 1002)
456             iobuf_write (a, ski->iv, ski->ivlen);
457
458         }
459       else /* Not protected. */
460         iobuf_put (a, 0 );
461
462       if (ski->s2k.mode == 1001)
463         ; /* GnuPG extension - don't write a secret key at all. */
464       else if (ski->s2k.mode == 1002)
465         {
466           /* GnuPG extension - divert to OpenPGP smartcard. */
467           /* Length of the serial number or 0 for no serial number. */
468           iobuf_put (a, ski->ivlen );
469           /* The serial number gets stored in the IV field.  */
470           iobuf_write (a, ski->iv, ski->ivlen);
471         }
472       else if (ski->is_protected)
473         {
474           /* The secret key is protected - write it out as it is.  */
475           byte *p;
476           unsigned int ndatabits;
477
478           log_assert (gcry_mpi_get_flag (pk->pkey[npkey], GCRYMPI_FLAG_OPAQUE));
479           p = gcry_mpi_get_opaque (pk->pkey[npkey], &ndatabits);
480           if (p)
481             iobuf_write (a, p, (ndatabits+7)/8 );
482         }
483       else
484         {
485           /* Non-protected key. */
486           for ( ; i < nskey; i++ )
487             if ( (err = gpg_mpi_write (a, pk->pkey[i])))
488               goto leave;
489           write_16 (a, ski->csum );
490         }
491     }
492
493  leave:
494   if (!err)
495     {
496       /* Build the header of the packet - which we must do after
497          writing all the other stuff, so that we know the length of
498          the packet */
499       write_header2 (out, ctb, iobuf_get_temp_length(a), 0);
500        /* And finally write it out to the real stream. */
501       err = iobuf_write_temp (out, a);
502     }
503
504   iobuf_close (a); /* Close the temporary buffer */
505   return err;
506 }
507
508
509 /* Serialize the symmetric-key encrypted session key packet (RFC 4880,
510  * 5.3) described by ENC and write it to OUT.
511  *
512  * CTB is the serialization's CTB.  It specifies the header format and
513  * the packet's type.  The header length must not be set.  */
514 static int
515 do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
516 {
517   int rc = 0;
518   IOBUF a = iobuf_temp();
519
520   log_assert (ctb_pkttype (ctb) == PKT_SYMKEY_ENC);
521
522   /* The only acceptable version.  */
523   log_assert( enc->version == 4 );
524
525   /* RFC 4880, Section 3.7.  */
526   switch (enc->s2k.mode)
527     {
528     case 0: /* Simple S2K.  */
529     case 1: /* Salted S2K.  */
530     case 3: /* Iterated and salted S2K.  */
531       break; /* Reasonable values.  */
532
533     default:
534       log_bug ("do_symkey_enc: s2k=%d\n", enc->s2k.mode);
535     }
536     iobuf_put( a, enc->version );
537     iobuf_put( a, enc->cipher_algo );
538     iobuf_put( a, enc->s2k.mode );
539     iobuf_put( a, enc->s2k.hash_algo );
540     if( enc->s2k.mode == 1 || enc->s2k.mode == 3 ) {
541         iobuf_write(a, enc->s2k.salt, 8 );
542         if( enc->s2k.mode == 3 )
543             iobuf_put(a, enc->s2k.count);
544     }
545     if( enc->seskeylen )
546         iobuf_write(a, enc->seskey, enc->seskeylen );
547
548     write_header(out, ctb, iobuf_get_temp_length(a) );
549     rc = iobuf_write_temp( out, a );
550
551     iobuf_close(a);
552     return rc;
553 }
554
555
556 /* Serialize the public-key encrypted session key packet (RFC 4880,
557    5.1) described by ENC and write it to OUT.
558
559    CTB is the serialization's CTB.  It specifies the header format and
560    the packet's type.  The header length must not be set.  */
561 static int
562 do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
563 {
564   int rc = 0;
565   int n, i;
566   IOBUF a = iobuf_temp();
567
568   log_assert (ctb_pkttype (ctb) == PKT_PUBKEY_ENC);
569
570   iobuf_put (a, 3); /* Version.  */
571
572   if ( enc->throw_keyid )
573     {
574       write_32(a, 0 );  /* Don't tell Eve who can decrypt the message.  */
575       write_32(a, 0 );
576     }
577   else
578     {
579       write_32(a, enc->keyid[0] );
580       write_32(a, enc->keyid[1] );
581     }
582   iobuf_put(a,enc->pubkey_algo );
583   n = pubkey_get_nenc( enc->pubkey_algo );
584   if ( !n )
585     write_fake_data( a, enc->data[0] );
586
587   for (i=0; i < n && !rc ; i++ )
588     {
589       if (enc->pubkey_algo == PUBKEY_ALGO_ECDH && i == 1)
590         rc = gpg_mpi_write_nohdr (a, enc->data[i]);
591       else
592         rc = gpg_mpi_write (a, enc->data[i]);
593     }
594
595   if (!rc)
596     {
597       write_header (out, ctb, iobuf_get_temp_length(a) );
598       rc = iobuf_write_temp (out, a);
599     }
600   iobuf_close(a);
601   return rc;
602 }
603
604
605 /* Calculate the length of the serialized plaintext packet PT (RFC
606    4480, Section 5.9).  */
607 static u32
608 calc_plaintext( PKT_plaintext *pt )
609 {
610   /* Truncate namelen to the maximum 255 characters.  Note this means
611      that a function that calls build_packet with an illegal literal
612      packet will get it back legalized. */
613
614   if(pt->namelen>255)
615     pt->namelen=255;
616
617   return pt->len? (1 + 1 + pt->namelen + 4 + pt->len) : 0;
618 }
619
620 /* Serialize the plaintext packet (RFC 4880, 5.9) described by PT and
621    write it to OUT.
622
623    The body of the message is stored in PT->BUF.  The amount of data
624    to write is PT->LEN.  (PT->BUF should be configured to return EOF
625    after this much data has been read.)  If PT->LEN is 0 and CTB
626    indicates that this is a new format packet, then partial block mode
627    is assumed to have been enabled on OUT.  On success, partial block
628    mode is disabled.
629
630    If PT->BUF is NULL, the caller must write out the data.  In
631    this case, if PT->LEN was 0, then partial body length mode was
632    enabled and the caller must disable it by calling
633    iobuf_set_partial_body_length_mode (out, 0).  */
634 static int
635 do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
636 {
637     int rc = 0;
638     size_t nbytes;
639
640     log_assert (ctb_pkttype (ctb) == PKT_PLAINTEXT);
641
642     write_header(out, ctb, calc_plaintext( pt ) );
643     log_assert (pt->mode == 'b' || pt->mode == 't' || pt->mode == 'u'
644                 || pt->mode == 'm'
645                 || pt->mode == 'l' || pt->mode == '1');
646     iobuf_put(out, pt->mode );
647     iobuf_put(out, pt->namelen );
648     iobuf_write (out, pt->name, pt->namelen);
649     rc = write_32(out, pt->timestamp );
650     if (rc)
651       return rc;
652
653     if (pt->buf)
654       {
655         nbytes = iobuf_copy (out, pt->buf);
656         if(ctb_new_format_p (ctb) && !pt->len)
657           /* Turn off partial body length mode.  */
658           iobuf_set_partial_body_length_mode (out, 0);
659         if( pt->len && nbytes != pt->len )
660           log_error("do_plaintext(): wrote %lu bytes but expected %lu bytes\n",
661                     (ulong)nbytes, (ulong)pt->len );
662       }
663
664     return rc;
665 }
666
667
668
669 /* Serialize the symmetrically encrypted data packet (RFC 4880,
670    Section 5.7) described by ED and write it to OUT.
671
672    Note: this only writes the packets header!  The call must then
673    follow up and write the initial random data and the body to OUT.
674    (If you use the encryption iobuf filter (cipher_filter), then this
675    is done automatically.)  */
676 static int
677 do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed )
678 {
679     int rc = 0;
680     u32 n;
681
682     log_assert (! ed->mdc_method);
683     log_assert (ctb_pkttype (ctb) == PKT_ENCRYPTED);
684
685     n = ed->len ? (ed->len + ed->extralen) : 0;
686     write_header(out, ctb, n );
687
688     /* This is all. The caller has to write the real data */
689
690     return rc;
691 }
692
693 /* Serialize the symmetrically encrypted integrity protected data
694    packet (RFC 4880, Section 5.13) described by ED and write it to
695    OUT.
696
697    Note: this only writes the packet's header!  The caller must then
698    follow up and write the initial random data, the body and the MDC
699    packet to OUT.  (If you use the encryption iobuf filter
700    (cipher_filter), then this is done automatically.)  */
701 static int
702 do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed )
703 {
704     int rc = 0;
705     u32 n;
706
707     log_assert (ed->mdc_method);
708     log_assert (ctb_pkttype (ctb) == PKT_ENCRYPTED_MDC);
709
710     /* Take version number and the following MDC packet in account. */
711     n = ed->len ? (ed->len + ed->extralen + 1 + 22) : 0;
712     write_header(out, ctb, n );
713     iobuf_put(out, 1 );  /* version */
714
715     /* This is all. The caller has to write the real data */
716
717     return rc;
718 }
719
720
721 /* Serialize the compressed packet (RFC 4880, Section 5.6) described
722    by CD and write it to OUT.
723
724    Note: this only writes the packet's header!  The caller must then
725    follow up and write the body to OUT.  */
726 static int
727 do_compressed( IOBUF out, int ctb, PKT_compressed *cd )
728 {
729     int rc = 0;
730
731     log_assert (ctb_pkttype (ctb) == PKT_COMPRESSED);
732
733     /* We must use the old convention and don't use blockmode for the
734        sake of PGP 2 compatibility.  However if the new_ctb flag was
735        set, CTB is already formatted as new style and write_header2
736        does create a partial length encoding using new the new
737        style. */
738     write_header2(out, ctb, 0, 0);
739     iobuf_put(out, cd->algorithm );
740
741     /* This is all. The caller has to write the real data */
742
743     return rc;
744 }
745
746
747 /****************
748  * Delete all subpackets of type REQTYPE and return a bool whether a packet
749  * was deleted.
750  */
751 int
752 delete_sig_subpkt (subpktarea_t *area, sigsubpkttype_t reqtype )
753 {
754     int buflen;
755     sigsubpkttype_t type;
756     byte *buffer, *bufstart;
757     size_t n;
758     size_t unused = 0;
759     int okay = 0;
760
761     if( !area )
762         return 0;
763     buflen = area->len;
764     buffer = area->data;
765     for(;;) {
766         if( !buflen ) {
767             okay = 1;
768             break;
769         }
770         bufstart = buffer;
771         n = *buffer++; buflen--;
772         if( n == 255 ) {
773             if( buflen < 4 )
774                 break;
775             n = buf32_to_size_t (buffer);
776             buffer += 4;
777             buflen -= 4;
778         }
779         else if( n >= 192 ) {
780             if( buflen < 2 )
781                 break;
782             n = (( n - 192 ) << 8) + *buffer + 192;
783             buffer++;
784             buflen--;
785         }
786         if( buflen < n )
787             break;
788
789         type = *buffer & 0x7f;
790         if( type == reqtype ) {
791             buffer++;
792             buflen--;
793             n--;
794             if( n > buflen )
795                 break;
796             buffer += n; /* point to next subpkt */
797             buflen -= n;
798             memmove (bufstart, buffer, buflen); /* shift */
799             unused +=  buffer - bufstart;
800             buffer = bufstart;
801         }
802         else {
803             buffer += n; buflen -=n;
804         }
805     }
806
807     if (!okay)
808         log_error ("delete_subpkt: buffer shorter than subpacket\n");
809     log_assert (unused <= area->len);
810     area->len -= unused;
811     return !!unused;
812 }
813
814
815 /****************
816  * Create or update a signature subpacket for SIG of TYPE.  This
817  * functions knows where to put the data (hashed or unhashed).  The
818  * function may move data from the unhashed part to the hashed one.
819  * Note: All pointers into sig->[un]hashed (e.g. returned by
820  * parse_sig_subpkt) are not valid after a call to this function.  The
821  * data to put into the subpaket should be in a buffer with a length
822  * of buflen.
823  */
824 void
825 build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
826                   const byte *buffer, size_t buflen )
827 {
828     byte *p;
829     int critical, hashed;
830     subpktarea_t *oldarea, *newarea;
831     size_t nlen, n, n0;
832
833     critical = (type & SIGSUBPKT_FLAG_CRITICAL);
834     type &= ~SIGSUBPKT_FLAG_CRITICAL;
835
836     /* Sanity check buffer sizes */
837     if(parse_one_sig_subpkt(buffer,buflen,type)<0)
838       BUG();
839
840     switch(type)
841       {
842       case SIGSUBPKT_NOTATION:
843       case SIGSUBPKT_POLICY:
844       case SIGSUBPKT_REV_KEY:
845       case SIGSUBPKT_SIGNATURE:
846         /* we do allow multiple subpackets */
847         break;
848
849       default:
850         /* we don't allow multiple subpackets */
851         delete_sig_subpkt(sig->hashed,type);
852         delete_sig_subpkt(sig->unhashed,type);
853         break;
854       }
855
856     /* Any special magic that needs to be done for this type so the
857        packet doesn't need to be reparsed? */
858     switch(type)
859       {
860       case SIGSUBPKT_NOTATION:
861         sig->flags.notation=1;
862         break;
863
864       case SIGSUBPKT_POLICY:
865         sig->flags.policy_url=1;
866         break;
867
868       case SIGSUBPKT_PREF_KS:
869         sig->flags.pref_ks=1;
870         break;
871
872       case SIGSUBPKT_EXPORTABLE:
873         if(buffer[0])
874           sig->flags.exportable=1;
875         else
876           sig->flags.exportable=0;
877         break;
878
879       case SIGSUBPKT_REVOCABLE:
880         if(buffer[0])
881           sig->flags.revocable=1;
882         else
883           sig->flags.revocable=0;
884         break;
885
886       case SIGSUBPKT_TRUST:
887         sig->trust_depth=buffer[0];
888         sig->trust_value=buffer[1];
889         break;
890
891       case SIGSUBPKT_REGEXP:
892         sig->trust_regexp=buffer;
893         break;
894
895         /* This should never happen since we don't currently allow
896            creating such a subpacket, but just in case... */
897       case SIGSUBPKT_SIG_EXPIRE:
898         if(buf32_to_u32(buffer)+sig->timestamp<=make_timestamp())
899           sig->flags.expired=1;
900         else
901           sig->flags.expired=0;
902         break;
903
904       default:
905         break;
906       }
907
908     if( (buflen+1) >= 8384 )
909         nlen = 5; /* write 5 byte length header */
910     else if( (buflen+1) >= 192 )
911         nlen = 2; /* write 2 byte length header */
912     else
913         nlen = 1; /* just a 1 byte length header */
914
915     switch( type )
916       {
917         /* The issuer being unhashed is a historical oddity.  It
918            should work equally as well hashed.  Of course, if even an
919            unhashed issuer is tampered with, it makes it awfully hard
920            to verify the sig... */
921       case SIGSUBPKT_ISSUER:
922       case SIGSUBPKT_SIGNATURE:
923         hashed = 0;
924         break;
925       default:
926         hashed = 1;
927         break;
928       }
929
930     if( critical )
931         type |= SIGSUBPKT_FLAG_CRITICAL;
932
933     oldarea = hashed? sig->hashed : sig->unhashed;
934
935     /* Calculate new size of the area and allocate */
936     n0 = oldarea? oldarea->len : 0;
937     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
938     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
939         newarea = oldarea;
940         /*log_debug ("updating area for type %d\n", type );*/
941     }
942     else if (oldarea) {
943         newarea = xrealloc (oldarea, sizeof (*newarea) + n - 1);
944         newarea->size = n;
945         /*log_debug ("reallocating area for type %d\n", type );*/
946     }
947     else {
948         newarea = xmalloc (sizeof (*newarea) + n - 1);
949         newarea->size = n;
950         /*log_debug ("allocating area for type %d\n", type );*/
951     }
952     newarea->len = n;
953
954     p = newarea->data + n0;
955     if (nlen == 5) {
956         *p++ = 255;
957         *p++ = (buflen+1) >> 24;
958         *p++ = (buflen+1) >> 16;
959         *p++ = (buflen+1) >>  8;
960         *p++ = (buflen+1);
961         *p++ = type;
962         memcpy (p, buffer, buflen);
963     }
964     else if (nlen == 2) {
965         *p++ = (buflen+1-192) / 256 + 192;
966         *p++ = (buflen+1-192) % 256;
967         *p++ = type;
968         memcpy (p, buffer, buflen);
969     }
970     else {
971         *p++ = buflen+1;
972         *p++ = type;
973         memcpy (p, buffer, buflen);
974     }
975
976     if (hashed)
977         sig->hashed = newarea;
978     else
979         sig->unhashed = newarea;
980 }
981
982 /*
983  * Put all the required stuff from SIG into subpackets of sig.
984  * PKSK is the signing key.
985  * Hmmm, should we delete those subpackets which are in a wrong area?
986  */
987 void
988 build_sig_subpkt_from_sig (PKT_signature *sig, PKT_public_key *pksk)
989 {
990     u32  u;
991     byte buf[1+MAX_FINGERPRINT_LEN];
992     size_t fprlen;
993
994     /* For v4 keys we need to write the ISSUER subpacket.  We do not
995      * want that for a future v5 format.  */
996     if (pksk->version < 5)
997       {
998         u = sig->keyid[0];
999         buf[0] = (u >> 24) & 0xff;
1000         buf[1] = (u >> 16) & 0xff;
1001         buf[2] = (u >>  8) & 0xff;
1002         buf[3] = u & 0xff;
1003         u = sig->keyid[1];
1004         buf[4] = (u >> 24) & 0xff;
1005         buf[5] = (u >> 16) & 0xff;
1006         buf[6] = (u >>  8) & 0xff;
1007         buf[7] = u & 0xff;
1008         build_sig_subpkt (sig, SIGSUBPKT_ISSUER, buf, 8);
1009       }
1010
1011     /* Write the new ISSUER_FPR subpacket.  */
1012     fingerprint_from_pk (pksk, buf+1, &fprlen);
1013     if (fprlen == 20)
1014       {
1015         buf[0] = pksk->version;
1016         build_sig_subpkt (sig, SIGSUBPKT_ISSUER_FPR, buf, 21);
1017       }
1018
1019     /* Write the timestamp.  */
1020     u = sig->timestamp;
1021     buf[0] = (u >> 24) & 0xff;
1022     buf[1] = (u >> 16) & 0xff;
1023     buf[2] = (u >>  8) & 0xff;
1024     buf[3] = u & 0xff;
1025     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
1026
1027     if(sig->expiredate)
1028       {
1029         if(sig->expiredate>sig->timestamp)
1030           u=sig->expiredate-sig->timestamp;
1031         else
1032           u=1; /* A 1-second expiration time is the shortest one
1033                   OpenPGP has */
1034
1035         buf[0] = (u >> 24) & 0xff;
1036         buf[1] = (u >> 16) & 0xff;
1037         buf[2] = (u >>  8) & 0xff;
1038         buf[3] = u & 0xff;
1039
1040         /* Mark this CRITICAL, so if any implementation doesn't
1041            understand sigs that can expire, it'll just disregard this
1042            sig altogether. */
1043
1044         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
1045                           buf, 4 );
1046       }
1047 }
1048
1049 void
1050 build_attribute_subpkt(PKT_user_id *uid,byte type,
1051                        const void *buf,u32 buflen,
1052                        const void *header,u32 headerlen)
1053 {
1054   byte *attrib;
1055   int idx;
1056
1057   if(1+headerlen+buflen>8383)
1058     idx=5;
1059   else if(1+headerlen+buflen>191)
1060     idx=2;
1061   else
1062     idx=1;
1063
1064   /* realloc uid->attrib_data to the right size */
1065
1066   uid->attrib_data=xrealloc(uid->attrib_data,
1067                              uid->attrib_len+idx+1+headerlen+buflen);
1068
1069   attrib=&uid->attrib_data[uid->attrib_len];
1070
1071   if(idx==5)
1072     {
1073       attrib[0]=255;
1074       attrib[1]=(1+headerlen+buflen) >> 24;
1075       attrib[2]=(1+headerlen+buflen) >> 16;
1076       attrib[3]=(1+headerlen+buflen) >> 8;
1077       attrib[4]=1+headerlen+buflen;
1078     }
1079   else if(idx==2)
1080     {
1081       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
1082       attrib[1]=(1+headerlen+buflen-192) % 256;
1083     }
1084   else
1085     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
1086
1087   attrib[idx++]=type;
1088
1089   /* Tack on our data at the end */
1090
1091   if(headerlen>0)
1092     memcpy(&attrib[idx],header,headerlen);
1093   memcpy(&attrib[idx+headerlen],buf,buflen);
1094   uid->attrib_len+=idx+headerlen+buflen;
1095 }
1096
1097 /* Returns a human-readable string corresponding to the notation.
1098    This ignores notation->value.  The caller must free the result.  */
1099 static char *
1100 notation_value_to_human_readable_string (struct notation *notation)
1101 {
1102   if(notation->bdat)
1103     /* Binary data.  */
1104     {
1105       size_t len = notation->blen;
1106       int i;
1107       char preview[20];
1108
1109       for (i = 0; i < len && i < sizeof (preview) - 1; i ++)
1110         if (isprint (notation->bdat[i]))
1111           preview[i] = notation->bdat[i];
1112         else
1113           preview[i] = '?';
1114       preview[i] = 0;
1115
1116       return xasprintf (_("[ not human readable (%zu bytes: %s%s) ]"),
1117                         len, preview, i < len ? "..." : "");
1118     }
1119   else
1120     /* The value is human-readable.  */
1121     return xstrdup (notation->value);
1122 }
1123
1124 /* Turn the notation described by the string STRING into a notation.
1125
1126    STRING has the form:
1127
1128      - -name - Delete the notation.
1129      - name@domain.name=value - Normal notation
1130      - !name@domain.name=value - Notation with critical bit set.
1131
1132    The caller must free the result using free_notation().  */
1133 struct notation *
1134 string_to_notation(const char *string,int is_utf8)
1135 {
1136   const char *s;
1137   int saw_at=0;
1138   struct notation *notation;
1139
1140   notation=xmalloc_clear(sizeof(*notation));
1141
1142   if(*string=='-')
1143     {
1144       notation->flags.ignore=1;
1145       string++;
1146     }
1147
1148   if(*string=='!')
1149     {
1150       notation->flags.critical=1;
1151       string++;
1152     }
1153
1154   /* If and when the IETF assigns some official name tags, we'll have
1155      to add them here. */
1156
1157   for( s=string ; *s != '='; s++ )
1158     {
1159       if( *s=='@')
1160         saw_at++;
1161
1162       /* -notationname is legal without an = sign */
1163       if(!*s && notation->flags.ignore)
1164         break;
1165
1166       if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
1167         {
1168           log_error(_("a notation name must have only printable characters"
1169                       " or spaces, and end with an '='\n") );
1170           goto fail;
1171         }
1172     }
1173
1174   notation->name=xmalloc((s-string)+1);
1175   strncpy(notation->name,string,s-string);
1176   notation->name[s-string]='\0';
1177
1178   if(!saw_at && !opt.expert)
1179     {
1180       log_error(_("a user notation name must contain the '@' character\n"));
1181       goto fail;
1182     }
1183
1184   if (saw_at > 1)
1185     {
1186       log_error(_("a notation name must not contain more than"
1187                   " one '@' character\n"));
1188       goto fail;
1189     }
1190
1191   if(*s)
1192     {
1193       const char *i=s+1;
1194       int highbit=0;
1195
1196       /* we only support printable text - therefore we enforce the use
1197          of only printable characters (an empty value is valid) */
1198       for(s++; *s ; s++ )
1199         {
1200           if ( !isascii (*s) )
1201             highbit=1;
1202           else if (iscntrl(*s))
1203             {
1204               log_error(_("a notation value must not use any"
1205                           " control characters\n"));
1206               goto fail;
1207             }
1208         }
1209
1210       if(!highbit || is_utf8)
1211         notation->value=xstrdup(i);
1212       else
1213         notation->value=native_to_utf8(i);
1214     }
1215
1216   return notation;
1217
1218  fail:
1219   free_notation(notation);
1220   return NULL;
1221 }
1222
1223 /* Like string_to_notation, but store opaque data rather than human
1224    readable data.  */
1225 struct notation *
1226 blob_to_notation(const char *name, const char *data, size_t len)
1227 {
1228   const char *s;
1229   int saw_at=0;
1230   struct notation *notation;
1231
1232   notation=xmalloc_clear(sizeof(*notation));
1233
1234   if(*name=='-')
1235     {
1236       notation->flags.ignore=1;
1237       name++;
1238     }
1239
1240   if(*name=='!')
1241     {
1242       notation->flags.critical=1;
1243       name++;
1244     }
1245
1246   /* If and when the IETF assigns some official name tags, we'll have
1247      to add them here. */
1248
1249   for( s=name ; *s; s++ )
1250     {
1251       if( *s=='@')
1252         saw_at++;
1253
1254       /* -notationname is legal without an = sign */
1255       if(!*s && notation->flags.ignore)
1256         break;
1257
1258       if (*s == '=')
1259         {
1260           log_error(_("a notation name may not contain an '=' character\n"));
1261           goto fail;
1262         }
1263
1264       if (!isascii (*s) || (!isgraph(*s) && !isspace(*s)))
1265         {
1266           log_error(_("a notation name must have only printable characters"
1267                       " or spaces\n") );
1268           goto fail;
1269         }
1270     }
1271
1272   notation->name=xstrdup (name);
1273
1274   if(!saw_at && !opt.expert)
1275     {
1276       log_error(_("a user notation name must contain the '@' character\n"));
1277       goto fail;
1278     }
1279
1280   if (saw_at > 1)
1281     {
1282       log_error(_("a notation name must not contain more than"
1283                   " one '@' character\n"));
1284       goto fail;
1285     }
1286
1287   notation->bdat = xmalloc (len);
1288   memcpy (notation->bdat, data, len);
1289   notation->blen = len;
1290
1291   notation->value = notation_value_to_human_readable_string (notation);
1292
1293   return notation;
1294
1295  fail:
1296   free_notation(notation);
1297   return NULL;
1298 }
1299
1300 struct notation *
1301 sig_to_notation(PKT_signature *sig)
1302 {
1303   const byte *p;
1304   size_t len;
1305   int seq = 0;
1306   int crit;
1307   notation_t list = NULL;
1308
1309   /* See RFC 4880, 5.2.3.16 for the format of notation data.  In
1310      short, a notation has:
1311
1312        - 4 bytes of flags
1313        - 2 byte name length (n1)
1314        - 2 byte value length (n2)
1315        - n1 bytes of name data
1316        - n2 bytes of value data
1317    */
1318   while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&len,&seq,&crit)))
1319     {
1320       int n1,n2;
1321       struct notation *n=NULL;
1322
1323       if(len<8)
1324         {
1325           log_info(_("WARNING: invalid notation data found\n"));
1326           continue;
1327         }
1328
1329       /* name length.  */
1330       n1=(p[4]<<8)|p[5];
1331       /* value length.  */
1332       n2=(p[6]<<8)|p[7];
1333
1334       if(8+n1+n2!=len)
1335         {
1336           log_info(_("WARNING: invalid notation data found\n"));
1337           continue;
1338         }
1339
1340       n=xmalloc_clear(sizeof(*n));
1341       n->name=xmalloc(n1+1);
1342
1343       memcpy(n->name,&p[8],n1);
1344       n->name[n1]='\0';
1345
1346       if(p[0]&0x80)
1347         /* The value is human-readable.  */
1348         {
1349           n->value=xmalloc(n2+1);
1350           memcpy(n->value,&p[8+n1],n2);
1351           n->value[n2]='\0';
1352           n->flags.human = 1;
1353         }
1354       else
1355         /* Binary data.  */
1356         {
1357           n->bdat=xmalloc(n2);
1358           n->blen=n2;
1359           memcpy(n->bdat,&p[8+n1],n2);
1360
1361           n->value = notation_value_to_human_readable_string (n);
1362         }
1363
1364       n->flags.critical=crit;
1365
1366       n->next=list;
1367       list=n;
1368     }
1369
1370   return list;
1371 }
1372
1373 /* Release the resources associated with the *list* of notations.  To
1374    release a single notation, make sure that notation->next is
1375    NULL.  */
1376 void
1377 free_notation(struct notation *notation)
1378 {
1379   while(notation)
1380     {
1381       struct notation *n=notation;
1382
1383       xfree(n->name);
1384       xfree(n->value);
1385       xfree(n->altvalue);
1386       xfree(n->bdat);
1387       notation=n->next;
1388       xfree(n);
1389     }
1390 }
1391
1392 /* Serialize the signature packet (RFC 4880, Section 5.2) described by
1393    SIG and write it to OUT.  */
1394 static int
1395 do_signature( IOBUF out, int ctb, PKT_signature *sig )
1396 {
1397   int rc = 0;
1398   int n, i;
1399   IOBUF a = iobuf_temp();
1400
1401   log_assert (ctb_pkttype (ctb) == PKT_SIGNATURE);
1402
1403   if ( !sig->version || sig->version == 3)
1404     {
1405       iobuf_put( a, 3 );
1406
1407       /* Version 3 packets don't support subpackets.  */
1408       log_assert (! sig->hashed);
1409       log_assert (! sig->unhashed);
1410     }
1411   else
1412     iobuf_put( a, sig->version );
1413   if ( sig->version < 4 )
1414     iobuf_put (a, 5 ); /* Constant */
1415   iobuf_put (a, sig->sig_class );
1416   if ( sig->version < 4 )
1417     {
1418       write_32(a, sig->timestamp );
1419       write_32(a, sig->keyid[0] );
1420       write_32(a, sig->keyid[1] );
1421     }
1422   iobuf_put(a, sig->pubkey_algo );
1423   iobuf_put(a, sig->digest_algo );
1424   if ( sig->version >= 4 )
1425     {
1426       size_t nn;
1427       /* Timestamp and keyid must have been packed into the subpackets
1428          prior to the call of this function, because these subpackets
1429          are hashed. */
1430       nn = sig->hashed? sig->hashed->len : 0;
1431       write_16(a, nn);
1432       if (nn)
1433         iobuf_write( a, sig->hashed->data, nn );
1434       nn = sig->unhashed? sig->unhashed->len : 0;
1435       write_16(a, nn);
1436       if (nn)
1437         iobuf_write( a, sig->unhashed->data, nn );
1438     }
1439   iobuf_put(a, sig->digest_start[0] );
1440   iobuf_put(a, sig->digest_start[1] );
1441   n = pubkey_get_nsig( sig->pubkey_algo );
1442   if ( !n )
1443     write_fake_data( a, sig->data[0] );
1444   for (i=0; i < n && !rc ; i++ )
1445     rc = gpg_mpi_write (a, sig->data[i] );
1446
1447   if (!rc)
1448     {
1449       if ( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1450         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1451       else
1452         write_header(out, ctb, iobuf_get_temp_length(a) );
1453       rc = iobuf_write_temp( out, a );
1454     }
1455
1456   iobuf_close(a);
1457   return rc;
1458 }
1459
1460
1461 /* Serialize the one-pass signature packet (RFC 4880, Section 5.4)
1462    described by OPS and write it to OUT.  */
1463 static int
1464 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1465 {
1466     log_assert (ctb_pkttype (ctb) == PKT_ONEPASS_SIG);
1467
1468     write_header(out, ctb, 4 + 8 + 1);
1469
1470     iobuf_put (out, 3);  /* Version.  */
1471     iobuf_put(out, ops->sig_class );
1472     iobuf_put(out, ops->digest_algo );
1473     iobuf_put(out, ops->pubkey_algo );
1474     write_32(out, ops->keyid[0] );
1475     write_32(out, ops->keyid[1] );
1476     iobuf_put(out, ops->last );
1477
1478     return 0;
1479 }
1480
1481
1482 /* Write a 16-bit quantity to OUT in big endian order.  */
1483 static int
1484 write_16(IOBUF out, u16 a)
1485 {
1486     iobuf_put(out, a>>8);
1487     if( iobuf_put(out,a) )
1488         return -1;
1489     return 0;
1490 }
1491
1492 /* Write a 32-bit quantity to OUT in big endian order.  */
1493 static int
1494 write_32(IOBUF out, u32 a)
1495 {
1496     iobuf_put(out, a>> 24);
1497     iobuf_put(out, a>> 16);
1498     iobuf_put(out, a>> 8);
1499     return iobuf_put(out, a);
1500 }
1501
1502
1503 /****************
1504  * calculate the length of a header.
1505  *
1506  * LEN is the length of the packet's body.  NEW_CTB is whether we are
1507  * using a new or old format packet.
1508  *
1509  * This function does not handle indeterminate lengths or partial body
1510  * lengths.  (If you pass LEN as 0, then this function assumes you
1511  * really mean an empty body.)
1512  */
1513 static int
1514 calc_header_length( u32 len, int new_ctb )
1515 {
1516     if( new_ctb ) {
1517         if( len < 192 )
1518             return 2;
1519         if( len < 8384 )
1520             return 3;
1521         else
1522             return 6;
1523     }
1524     if( len < 256 )
1525         return 2;
1526     if( len < 65536 )
1527         return 3;
1528
1529     return 5;
1530 }
1531
1532 /****************
1533  * Write the CTB and the packet length
1534  */
1535 static int
1536 write_header( IOBUF out, int ctb, u32 len )
1537 {
1538     return write_header2( out, ctb, len, 0 );
1539 }
1540
1541
1542 static int
1543 write_sign_packet_header (IOBUF out, int ctb, u32 len)
1544 {
1545   (void)ctb;
1546
1547   /* Work around a bug in the pgp read function for signature packets,
1548      which are not correctly coded and silently assume at some point 2
1549      byte length headers.*/
1550   iobuf_put (out, 0x89 );
1551   iobuf_put (out, len >> 8 );
1552   return iobuf_put (out, len) == -1 ? -1:0;
1553 }
1554
1555 /****************
1556  * Write a packet header to OUT.
1557  *
1558  * CTB is the ctb.  It determines whether a new or old format packet
1559  * header should be written.  The length field is adjusted, but the
1560  * CTB is otherwise written out as is.
1561  *
1562  * LEN is the length of the packet's body.
1563  *
1564  * If HDRLEN is set, then we don't necessarily use the most efficient
1565  * encoding to store LEN, but the specified length.  (If this is not
1566  * possible, this is a bug.)  In this case, LEN=0 means a 0 length
1567  * packet.  Note: setting HDRLEN is only supported for old format
1568  * packets!
1569  *
1570  * If HDRLEN is not set, then the shortest encoding is used.  In this
1571  * case, LEN=0 means the body has an indeterminate length and a
1572  * partial body length header (if a new format packet) or an
1573  * indeterminate length header (if an old format packet) is written
1574  * out.  Further, if using partial body lengths, this enables partial
1575  * body length mode on OUT.
1576  */
1577 static int
1578 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1579 {
1580   if (ctb_new_format_p (ctb))
1581     return write_new_header( out, ctb, len, hdrlen );
1582
1583   /* An old format packet.  Refer to RFC 4880, Section 4.2.1 to
1584      understand how lengths are encoded in this case.  */
1585
1586   /* The length encoding is stored in the two least significant bits.
1587      Make sure they are cleared.  */
1588   log_assert ((ctb & 3) == 0);
1589
1590   log_assert (hdrlen == 0 || hdrlen == 2 || hdrlen == 3 || hdrlen == 5);
1591
1592   if (hdrlen)
1593     /* Header length is given.  */
1594     {
1595       if( hdrlen == 2 && len < 256 )
1596         /* 00 => 1 byte length.  */
1597         ;
1598       else if( hdrlen == 3 && len < 65536 )
1599         /* 01 => 2 byte length.  If len < 256, this is not the most
1600            compact encoding, but it is a correct encoding.  */
1601         ctb |= 1;
1602       else if (hdrlen == 5)
1603         /* 10 => 4 byte length.  If len < 65536, this is not the most
1604            compact encoding, but it is a correct encoding.  */
1605         ctb |= 2;
1606       else
1607         log_bug ("Can't encode length=%d in a %d byte header!\n",
1608                  len, hdrlen);
1609     }
1610   else
1611     {
1612       if( !len )
1613         /* 11 => Indeterminate length.  */
1614         ctb |= 3;
1615       else if( len < 256 )
1616         /* 00 => 1 byte length.  */
1617         ;
1618       else if( len < 65536 )
1619         /* 01 => 2 byte length.  */
1620         ctb |= 1;
1621       else
1622         /* 10 => 4 byte length.  */
1623         ctb |= 2;
1624     }
1625
1626   if( iobuf_put(out, ctb ) )
1627     return -1;
1628
1629   if( len || hdrlen )
1630     {
1631       if( ctb & 2 )
1632         {
1633           if(iobuf_put(out, len >> 24 ))
1634             return -1;
1635           if(iobuf_put(out, len >> 16 ))
1636             return -1;
1637         }
1638
1639       if( ctb & 3 )
1640         if(iobuf_put(out, len >> 8 ))
1641           return -1;
1642
1643       if( iobuf_put(out, len ) )
1644         return -1;
1645     }
1646
1647   return 0;
1648 }
1649
1650
1651 /* Write a new format header to OUT.
1652
1653    CTB is the ctb.
1654
1655    LEN is the length of the packet's body.  If LEN is 0, then enables
1656    partial body length mode (i.e., the body is of an indeterminant
1657    length) on OUT.  Note: this function cannot be used to generate a
1658    header for a zero length packet.
1659
1660    HDRLEN is the length of the packet's header.  If HDRLEN is 0, the
1661    shortest encoding is chosen based on the length of the packet's
1662    body.  Currently, values other than 0 are not supported.
1663
1664    Returns 0 on success.  */
1665 static int
1666 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1667 {
1668     if( hdrlen )
1669         log_bug("can't cope with hdrlen yet\n");
1670
1671     if( iobuf_put(out, ctb ) )
1672         return -1;
1673     if( !len ) {
1674         iobuf_set_partial_body_length_mode(out, 512 );
1675     }
1676     else {
1677         if( len < 192 ) {
1678             if( iobuf_put(out, len ) )
1679                 return -1;
1680         }
1681         else if( len < 8384 ) {
1682             len -= 192;
1683             if( iobuf_put( out, (len / 256) + 192) )
1684                 return -1;
1685             if( iobuf_put( out, (len % 256) )  )
1686                 return -1;
1687         }
1688         else {
1689             if( iobuf_put( out, 0xff ) )
1690                 return -1;
1691             if( iobuf_put( out, (len >> 24)&0xff ) )
1692                 return -1;
1693             if( iobuf_put( out, (len >> 16)&0xff ) )
1694                 return -1;
1695             if( iobuf_put( out, (len >> 8)&0xff )  )
1696                 return -1;
1697             if( iobuf_put( out, len & 0xff ) )
1698                 return -1;
1699         }
1700     }
1701     return 0;
1702 }