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