gpg: Improve documentation and comments related to OpenPGP packets.
[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&0x40) && !pt->len )
642       iobuf_set_partial_body_length_mode(out, 0 ); /* turn off partial */
643     if( pt->len && nbytes != pt->len )
644       log_error("do_plaintext(): wrote %lu bytes but expected %lu bytes\n",
645                 (ulong)nbytes, (ulong)pt->len );
646
647     return rc;
648 }
649
650
651
652 /* Serialize the symmetrically encrypted data packet (RFC 4880,
653    Section 5.7) described by ED and write it to OUT.
654
655    Note: this only writes the packets header!  The call must then
656    follow up and write the initial random data and the body to OUT.
657    (If you use the encryption iobuf filter (cipher_filter), then this
658    is done automatically.)  */
659 static int
660 do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed )
661 {
662     int rc = 0;
663     u32 n;
664
665     log_assert (! ed->mdc_method);
666     log_assert (ctb_pkttype (ctb) == PKT_ENCRYPTED);
667
668     n = ed->len ? (ed->len + ed->extralen) : 0;
669     write_header(out, ctb, n );
670
671     /* This is all. The caller has to write the real data */
672
673     return rc;
674 }
675
676 /* Serialize the symmetrically encrypted integrity protected data
677    packet (RFC 4880, Section 5.13) described by ED and write it to
678    OUT.
679
680    Note: this only writes the packet's header!  The caller must then
681    follow up and write the initial random data, the body and the MDC
682    packet to OUT.  (If you use the encryption iobuf filter
683    (cipher_filter), then this is done automatically.)  */
684 static int
685 do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed )
686 {
687     int rc = 0;
688     u32 n;
689
690     log_assert (ed->mdc_method);
691     log_assert (ctb_pkttype (ctb) == PKT_ENCRYPTED_MDC);
692
693     /* Take version number and the following MDC packet in account. */
694     n = ed->len ? (ed->len + ed->extralen + 1 + 22) : 0;
695     write_header(out, ctb, n );
696     iobuf_put(out, 1 );  /* version */
697
698     /* This is all. The caller has to write the real data */
699
700     return rc;
701 }
702
703
704 /* Serialize the compressed packet (RFC 4880, Section 5.6) described
705    by CD and write it to OUT.
706
707    Note: this only writes the packet's header!  The caller must then
708    follow up and write the body to OUT.  */
709 static int
710 do_compressed( IOBUF out, int ctb, PKT_compressed *cd )
711 {
712     int rc = 0;
713
714     log_assert (ctb_pkttype (ctb) == PKT_COMPRESSED);
715
716     /* We must use the old convention and don't use blockmode for the
717        sake of PGP 2 compatibility.  However if the new_ctb flag was
718        set, CTB is already formatted as new style and write_header2
719        does create a partial length encoding using new the new
720        style. */
721     write_header2(out, ctb, 0, 0);
722     iobuf_put(out, cd->algorithm );
723
724     /* This is all. The caller has to write the real data */
725
726     return rc;
727 }
728
729
730 /****************
731  * Delete all subpackets of type REQTYPE and return a bool whether a packet
732  * was deleted.
733  */
734 int
735 delete_sig_subpkt (subpktarea_t *area, sigsubpkttype_t reqtype )
736 {
737     int buflen;
738     sigsubpkttype_t type;
739     byte *buffer, *bufstart;
740     size_t n;
741     size_t unused = 0;
742     int okay = 0;
743
744     if( !area )
745         return 0;
746     buflen = area->len;
747     buffer = area->data;
748     for(;;) {
749         if( !buflen ) {
750             okay = 1;
751             break;
752         }
753         bufstart = buffer;
754         n = *buffer++; buflen--;
755         if( n == 255 ) {
756             if( buflen < 4 )
757                 break;
758             n = buf32_to_size_t (buffer);
759             buffer += 4;
760             buflen -= 4;
761         }
762         else if( n >= 192 ) {
763             if( buflen < 2 )
764                 break;
765             n = (( n - 192 ) << 8) + *buffer + 192;
766             buffer++;
767             buflen--;
768         }
769         if( buflen < n )
770             break;
771
772         type = *buffer & 0x7f;
773         if( type == reqtype ) {
774             buffer++;
775             buflen--;
776             n--;
777             if( n > buflen )
778                 break;
779             buffer += n; /* point to next subpkt */
780             buflen -= n;
781             memmove (bufstart, buffer, buflen); /* shift */
782             unused +=  buffer - bufstart;
783             buffer = bufstart;
784         }
785         else {
786             buffer += n; buflen -=n;
787         }
788     }
789
790     if (!okay)
791         log_error ("delete_subpkt: buffer shorter than subpacket\n");
792     assert (unused <= area->len);
793     area->len -= unused;
794     return !!unused;
795 }
796
797
798 /****************
799  * Create or update a signature subpacket for SIG of TYPE.  This
800  * functions knows where to put the data (hashed or unhashed).  The
801  * function may move data from the unhashed part to the hashed one.
802  * Note: All pointers into sig->[un]hashed (e.g. returned by
803  * parse_sig_subpkt) are not valid after a call to this function.  The
804  * data to put into the subpaket should be in a buffer with a length
805  * of buflen.
806  */
807 void
808 build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
809                   const byte *buffer, size_t buflen )
810 {
811     byte *p;
812     int critical, hashed;
813     subpktarea_t *oldarea, *newarea;
814     size_t nlen, n, n0;
815
816     critical = (type & SIGSUBPKT_FLAG_CRITICAL);
817     type &= ~SIGSUBPKT_FLAG_CRITICAL;
818
819     /* Sanity check buffer sizes */
820     if(parse_one_sig_subpkt(buffer,buflen,type)<0)
821       BUG();
822
823     switch(type)
824       {
825       case SIGSUBPKT_NOTATION:
826       case SIGSUBPKT_POLICY:
827       case SIGSUBPKT_REV_KEY:
828       case SIGSUBPKT_SIGNATURE:
829         /* we do allow multiple subpackets */
830         break;
831
832       default:
833         /* we don't allow multiple subpackets */
834         delete_sig_subpkt(sig->hashed,type);
835         delete_sig_subpkt(sig->unhashed,type);
836         break;
837       }
838
839     /* Any special magic that needs to be done for this type so the
840        packet doesn't need to be reparsed? */
841     switch(type)
842       {
843       case SIGSUBPKT_NOTATION:
844         sig->flags.notation=1;
845         break;
846
847       case SIGSUBPKT_POLICY:
848         sig->flags.policy_url=1;
849         break;
850
851       case SIGSUBPKT_PREF_KS:
852         sig->flags.pref_ks=1;
853         break;
854
855       case SIGSUBPKT_EXPORTABLE:
856         if(buffer[0])
857           sig->flags.exportable=1;
858         else
859           sig->flags.exportable=0;
860         break;
861
862       case SIGSUBPKT_REVOCABLE:
863         if(buffer[0])
864           sig->flags.revocable=1;
865         else
866           sig->flags.revocable=0;
867         break;
868
869       case SIGSUBPKT_TRUST:
870         sig->trust_depth=buffer[0];
871         sig->trust_value=buffer[1];
872         break;
873
874       case SIGSUBPKT_REGEXP:
875         sig->trust_regexp=buffer;
876         break;
877
878         /* This should never happen since we don't currently allow
879            creating such a subpacket, but just in case... */
880       case SIGSUBPKT_SIG_EXPIRE:
881         if(buf32_to_u32(buffer)+sig->timestamp<=make_timestamp())
882           sig->flags.expired=1;
883         else
884           sig->flags.expired=0;
885         break;
886
887       default:
888         break;
889       }
890
891     if( (buflen+1) >= 8384 )
892         nlen = 5; /* write 5 byte length header */
893     else if( (buflen+1) >= 192 )
894         nlen = 2; /* write 2 byte length header */
895     else
896         nlen = 1; /* just a 1 byte length header */
897
898     switch( type )
899       {
900         /* The issuer being unhashed is a historical oddity.  It
901            should work equally as well hashed.  Of course, if even an
902            unhashed issuer is tampered with, it makes it awfully hard
903            to verify the sig... */
904       case SIGSUBPKT_ISSUER:
905       case SIGSUBPKT_SIGNATURE:
906         hashed = 0;
907         break;
908       default:
909         hashed = 1;
910         break;
911       }
912
913     if( critical )
914         type |= SIGSUBPKT_FLAG_CRITICAL;
915
916     oldarea = hashed? sig->hashed : sig->unhashed;
917
918     /* Calculate new size of the area and allocate */
919     n0 = oldarea? oldarea->len : 0;
920     n = n0 + nlen + 1 + buflen; /* length, type, buffer */
921     if (oldarea && n <= oldarea->size) { /* fits into the unused space */
922         newarea = oldarea;
923         /*log_debug ("updating area for type %d\n", type );*/
924     }
925     else if (oldarea) {
926         newarea = xrealloc (oldarea, sizeof (*newarea) + n - 1);
927         newarea->size = n;
928         /*log_debug ("reallocating area for type %d\n", type );*/
929     }
930     else {
931         newarea = xmalloc (sizeof (*newarea) + n - 1);
932         newarea->size = n;
933         /*log_debug ("allocating area for type %d\n", type );*/
934     }
935     newarea->len = n;
936
937     p = newarea->data + n0;
938     if (nlen == 5) {
939         *p++ = 255;
940         *p++ = (buflen+1) >> 24;
941         *p++ = (buflen+1) >> 16;
942         *p++ = (buflen+1) >>  8;
943         *p++ = (buflen+1);
944         *p++ = type;
945         memcpy (p, buffer, buflen);
946     }
947     else if (nlen == 2) {
948         *p++ = (buflen+1-192) / 256 + 192;
949         *p++ = (buflen+1-192) % 256;
950         *p++ = type;
951         memcpy (p, buffer, buflen);
952     }
953     else {
954         *p++ = buflen+1;
955         *p++ = type;
956         memcpy (p, buffer, buflen);
957     }
958
959     if (hashed)
960         sig->hashed = newarea;
961     else
962         sig->unhashed = newarea;
963 }
964
965 /****************
966  * Put all the required stuff from SIG into subpackets of sig.
967  * Hmmm, should we delete those subpackets which are in a wrong area?
968  */
969 void
970 build_sig_subpkt_from_sig( PKT_signature *sig )
971 {
972     u32  u;
973     byte buf[8];
974
975     u = sig->keyid[0];
976     buf[0] = (u >> 24) & 0xff;
977     buf[1] = (u >> 16) & 0xff;
978     buf[2] = (u >>  8) & 0xff;
979     buf[3] = u & 0xff;
980     u = sig->keyid[1];
981     buf[4] = (u >> 24) & 0xff;
982     buf[5] = (u >> 16) & 0xff;
983     buf[6] = (u >>  8) & 0xff;
984     buf[7] = u & 0xff;
985     build_sig_subpkt( sig, SIGSUBPKT_ISSUER, buf, 8 );
986
987     u = sig->timestamp;
988     buf[0] = (u >> 24) & 0xff;
989     buf[1] = (u >> 16) & 0xff;
990     buf[2] = (u >>  8) & 0xff;
991     buf[3] = u & 0xff;
992     build_sig_subpkt( sig, SIGSUBPKT_SIG_CREATED, buf, 4 );
993
994     if(sig->expiredate)
995       {
996         if(sig->expiredate>sig->timestamp)
997           u=sig->expiredate-sig->timestamp;
998         else
999           u=1; /* A 1-second expiration time is the shortest one
1000                   OpenPGP has */
1001
1002         buf[0] = (u >> 24) & 0xff;
1003         buf[1] = (u >> 16) & 0xff;
1004         buf[2] = (u >>  8) & 0xff;
1005         buf[3] = u & 0xff;
1006
1007         /* Mark this CRITICAL, so if any implementation doesn't
1008            understand sigs that can expire, it'll just disregard this
1009            sig altogether. */
1010
1011         build_sig_subpkt( sig, SIGSUBPKT_SIG_EXPIRE | SIGSUBPKT_FLAG_CRITICAL,
1012                           buf, 4 );
1013       }
1014 }
1015
1016 void
1017 build_attribute_subpkt(PKT_user_id *uid,byte type,
1018                        const void *buf,u32 buflen,
1019                        const void *header,u32 headerlen)
1020 {
1021   byte *attrib;
1022   int idx;
1023
1024   if(1+headerlen+buflen>8383)
1025     idx=5;
1026   else if(1+headerlen+buflen>191)
1027     idx=2;
1028   else
1029     idx=1;
1030
1031   /* realloc uid->attrib_data to the right size */
1032
1033   uid->attrib_data=xrealloc(uid->attrib_data,
1034                              uid->attrib_len+idx+1+headerlen+buflen);
1035
1036   attrib=&uid->attrib_data[uid->attrib_len];
1037
1038   if(idx==5)
1039     {
1040       attrib[0]=255;
1041       attrib[1]=(1+headerlen+buflen) >> 24;
1042       attrib[2]=(1+headerlen+buflen) >> 16;
1043       attrib[3]=(1+headerlen+buflen) >> 8;
1044       attrib[4]=1+headerlen+buflen;
1045     }
1046   else if(idx==2)
1047     {
1048       attrib[0]=(1+headerlen+buflen-192) / 256 + 192;
1049       attrib[1]=(1+headerlen+buflen-192) % 256;
1050     }
1051   else
1052     attrib[0]=1+headerlen+buflen; /* Good luck finding a JPEG this small! */
1053
1054   attrib[idx++]=type;
1055
1056   /* Tack on our data at the end */
1057
1058   if(headerlen>0)
1059     memcpy(&attrib[idx],header,headerlen);
1060   memcpy(&attrib[idx+headerlen],buf,buflen);
1061   uid->attrib_len+=idx+headerlen+buflen;
1062 }
1063
1064 /* Turn the notation described by the string STRING into a notation.
1065
1066    STRING has the form:
1067
1068      - -name - Delete the notation.
1069      - name@domain.name=value - Normal notation
1070      - !name@domain.name=value - Notation with critical bit set.
1071
1072    The caller must free the result using free_notation().  */
1073 struct notation *
1074 string_to_notation(const char *string,int is_utf8)
1075 {
1076   const char *s;
1077   int saw_at=0;
1078   struct notation *notation;
1079
1080   notation=xmalloc_clear(sizeof(*notation));
1081
1082   if(*string=='-')
1083     {
1084       notation->flags.ignore=1;
1085       string++;
1086     }
1087
1088   if(*string=='!')
1089     {
1090       notation->flags.critical=1;
1091       string++;
1092     }
1093
1094   /* If and when the IETF assigns some official name tags, we'll have
1095      to add them here. */
1096
1097   for( s=string ; *s != '='; s++ )
1098     {
1099       if( *s=='@')
1100         saw_at++;
1101
1102       /* -notationname is legal without an = sign */
1103       if(!*s && notation->flags.ignore)
1104         break;
1105
1106       if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
1107         {
1108           log_error(_("a notation name must have only printable characters"
1109                       " or spaces, and end with an '='\n") );
1110           goto fail;
1111         }
1112     }
1113
1114   notation->name=xmalloc((s-string)+1);
1115   strncpy(notation->name,string,s-string);
1116   notation->name[s-string]='\0';
1117
1118   if(!saw_at && !opt.expert)
1119     {
1120       log_error(_("a user notation name must contain the '@' character\n"));
1121       goto fail;
1122     }
1123
1124   if (saw_at > 1)
1125     {
1126       log_error(_("a notation name must not contain more than"
1127                   " one '@' character\n"));
1128       goto fail;
1129     }
1130
1131   if(*s)
1132     {
1133       const char *i=s+1;
1134       int highbit=0;
1135
1136       /* we only support printable text - therefore we enforce the use
1137          of only printable characters (an empty value is valid) */
1138       for(s++; *s ; s++ )
1139         {
1140           if ( !isascii (*s) )
1141             highbit=1;
1142           else if (iscntrl(*s))
1143             {
1144               log_error(_("a notation value must not use any"
1145                           " control characters\n"));
1146               goto fail;
1147             }
1148         }
1149
1150       if(!highbit || is_utf8)
1151         notation->value=xstrdup(i);
1152       else
1153         notation->value=native_to_utf8(i);
1154     }
1155
1156   return notation;
1157
1158  fail:
1159   free_notation(notation);
1160   return NULL;
1161 }
1162
1163 /* Return all of the notations stored in the signature SIG.  The
1164    caller must free them using free_notation().  */
1165 struct notation *
1166 sig_to_notation(PKT_signature *sig)
1167 {
1168   const byte *p;
1169   size_t len;
1170   int seq=0,crit;
1171   struct notation *list=NULL;
1172
1173   /* See RFC 4880, 5.2.3.16 for the format of notation data.  In
1174      short, a notation has:
1175
1176        - 4 bytes of flags
1177        - 2 byte name length (n1)
1178        - 2 byte value length (n2)
1179        - n1 bytes of name data
1180        - n2 bytes of value data
1181    */
1182   while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&len,&seq,&crit)))
1183     {
1184       int n1,n2;
1185       struct notation *n=NULL;
1186
1187       if(len<8)
1188         {
1189           log_info(_("WARNING: invalid notation data found\n"));
1190           continue;
1191         }
1192
1193       /* name length.  */
1194       n1=(p[4]<<8)|p[5];
1195       /* value length.  */
1196       n2=(p[6]<<8)|p[7];
1197
1198       if(8+n1+n2!=len)
1199         {
1200           log_info(_("WARNING: invalid notation data found\n"));
1201           continue;
1202         }
1203
1204       n=xmalloc_clear(sizeof(*n));
1205       n->name=xmalloc(n1+1);
1206
1207       memcpy(n->name,&p[8],n1);
1208       n->name[n1]='\0';
1209
1210       if(p[0]&0x80)
1211         /* The value is human-readable.  */
1212         {
1213           n->value=xmalloc(n2+1);
1214           memcpy(n->value,&p[8+n1],n2);
1215           n->value[n2]='\0';
1216         }
1217       else
1218         /* Binary data.  */
1219         {
1220           n->bdat=xmalloc(n2);
1221           n->blen=n2;
1222           memcpy(n->bdat,&p[8+n1],n2);
1223
1224           n->value=xmalloc(2+strlen(_("not human readable"))+2+1);
1225           strcpy(n->value,"[ ");
1226           strcat(n->value,_("not human readable"));
1227           strcat(n->value," ]");
1228         }
1229
1230       n->flags.critical=crit;
1231
1232       n->next=list;
1233       list=n;
1234     }
1235
1236   return list;
1237 }
1238
1239 /* Release the resources associated with the *list* of notations.  To
1240    release a single notation, make sure that notation->next is
1241    NULL.  */
1242 void
1243 free_notation(struct notation *notation)
1244 {
1245   while(notation)
1246     {
1247       struct notation *n=notation;
1248
1249       xfree(n->name);
1250       xfree(n->value);
1251       xfree(n->altvalue);
1252       xfree(n->bdat);
1253       notation=n->next;
1254       xfree(n);
1255     }
1256 }
1257
1258 /* Serialize the signature packet (RFC 4880, Section 5.2) described by
1259    SIG and write it to OUT.  */
1260 static int
1261 do_signature( IOBUF out, int ctb, PKT_signature *sig )
1262 {
1263   int rc = 0;
1264   int n, i;
1265   IOBUF a = iobuf_temp();
1266
1267   log_assert (ctb_pkttype (ctb) == PKT_SIGNATURE);
1268
1269   if ( !sig->version || sig->version == 3)
1270     {
1271       iobuf_put( a, 3 );
1272
1273       /* Version 3 packets don't support subpackets.  */
1274       log_assert (! sig->hashed);
1275       log_assert (! sig->unhashed);
1276     }
1277   else
1278     iobuf_put( a, sig->version );
1279   if ( sig->version < 4 )
1280     iobuf_put (a, 5 ); /* Constant */
1281   iobuf_put (a, sig->sig_class );
1282   if ( sig->version < 4 )
1283     {
1284       write_32(a, sig->timestamp );
1285       write_32(a, sig->keyid[0] );
1286       write_32(a, sig->keyid[1] );
1287     }
1288   iobuf_put(a, sig->pubkey_algo );
1289   iobuf_put(a, sig->digest_algo );
1290   if ( sig->version >= 4 )
1291     {
1292       size_t nn;
1293       /* Timestamp and keyid must have been packed into the subpackets
1294          prior to the call of this function, because these subpackets
1295          are hashed. */
1296       nn = sig->hashed? sig->hashed->len : 0;
1297       write_16(a, nn);
1298       if (nn)
1299         iobuf_write( a, sig->hashed->data, nn );
1300       nn = sig->unhashed? sig->unhashed->len : 0;
1301       write_16(a, nn);
1302       if (nn)
1303         iobuf_write( a, sig->unhashed->data, nn );
1304     }
1305   iobuf_put(a, sig->digest_start[0] );
1306   iobuf_put(a, sig->digest_start[1] );
1307   n = pubkey_get_nsig( sig->pubkey_algo );
1308   if ( !n )
1309     write_fake_data( a, sig->data[0] );
1310   for (i=0; i < n && !rc ; i++ )
1311     rc = gpg_mpi_write (a, sig->data[i] );
1312
1313   if (!rc)
1314     {
1315       if ( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1316         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1317       else
1318         write_header(out, ctb, iobuf_get_temp_length(a) );
1319       rc = iobuf_write_temp( out, a );
1320     }
1321
1322   iobuf_close(a);
1323   return rc;
1324 }
1325
1326
1327 /* Serialize the one-pass signature packet (RFC 4880, Section 5.4)
1328    described by OPS and write it to OUT.  */
1329 static int
1330 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1331 {
1332   log_assert (ctb_pkttype (ctb) == PKT_ONEPASS_SIG);
1333
1334     write_header(out, ctb, 4 + 8 + 1);
1335
1336     iobuf_put (out, 3);  /* Version.  */
1337     iobuf_put(out, ops->sig_class );
1338     iobuf_put(out, ops->digest_algo );
1339     iobuf_put(out, ops->pubkey_algo );
1340     write_32(out, ops->keyid[0] );
1341     write_32(out, ops->keyid[1] );
1342     iobuf_put(out, ops->last );
1343
1344     return 0;
1345 }
1346
1347
1348 /* Write a 16-bit quantity to OUT in big endian order.  */
1349 static int
1350 write_16(IOBUF out, u16 a)
1351 {
1352     iobuf_put(out, a>>8);
1353     if( iobuf_put(out,a) )
1354         return -1;
1355     return 0;
1356 }
1357
1358 /* Write a 32-bit quantity to OUT in big endian order.  */
1359 static int
1360 write_32(IOBUF out, u32 a)
1361 {
1362     iobuf_put(out, a>> 24);
1363     iobuf_put(out, a>> 16);
1364     iobuf_put(out, a>> 8);
1365     return iobuf_put(out, a);
1366 }
1367
1368
1369 /****************
1370  * calculate the length of a header.
1371  *
1372  * LEN is the length of the packet's body.  NEW_CTB is whether we are
1373  * using a new or old format packet.
1374  *
1375  * This function does not handle indeterminate lengths or partial body
1376  * lengths.  (If you pass LEN as 0, then this function assumes you
1377  * really mean an empty body.)
1378  */
1379 static int
1380 calc_header_length( u32 len, int new_ctb )
1381 {
1382     if( new_ctb ) {
1383         if( len < 192 )
1384             return 2;
1385         if( len < 8384 )
1386             return 3;
1387         else
1388             return 6;
1389     }
1390     if( len < 256 )
1391         return 2;
1392     if( len < 65536 )
1393         return 3;
1394
1395     return 5;
1396 }
1397
1398 /****************
1399  * Write the CTB and the packet length
1400  */
1401 static int
1402 write_header( IOBUF out, int ctb, u32 len )
1403 {
1404     return write_header2( out, ctb, len, 0 );
1405 }
1406
1407
1408 static int
1409 write_sign_packet_header (IOBUF out, int ctb, u32 len)
1410 {
1411   (void)ctb;
1412
1413   /* Work around a bug in the pgp read function for signature packets,
1414      which are not correctly coded and silently assume at some point 2
1415      byte length headers.*/
1416   iobuf_put (out, 0x89 );
1417   iobuf_put (out, len >> 8 );
1418   return iobuf_put (out, len) == -1 ? -1:0;
1419 }
1420
1421 /****************
1422  * Write a packet header to OUT.
1423  *
1424  * CTB is the ctb.  It determines whether a new or old format packet
1425  * header should be written.  The length field is adjusted, but the
1426  * CTB is otherwise written out as is.
1427  *
1428  * LEN is the length of the packet's body.
1429  *
1430  * If HDRLEN is set, then we don't necessarily use the most efficient
1431  * encoding to store LEN, but the specified length.  (If this is not
1432  * possible, this is a bug.)  In this case, LEN=0 means a 0 length
1433  * packet.  Note: setting HDRLEN is only supported for old format
1434  * packets!
1435  *
1436  * If HDRLEN is not set, then the shortest encoding is used.  In this
1437  * case, LEN=0 means the body has an indeterminate length and a
1438  * partial body length header (if a new format packet) or an
1439  * indeterminate length header (if an old format packet) is written
1440  * out.  Further, if using partial body lengths, this enables partial
1441  * body length mode on OUT.
1442  */
1443 static int
1444 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1445 {
1446   if( ctb & 0x40 )
1447     return write_new_header( out, ctb, len, hdrlen );
1448
1449   /* An old format packet.  Refer to RFC 4880, Section 4.2.1 to
1450      understand how lengths are encoded in this case.  */
1451
1452   log_assert (hdrlen == 0 || hdrlen == 2 || hdrlen == 3 || hdrlen == 5);
1453
1454   if (hdrlen)
1455     /* Header length is given.  */
1456     {
1457       if( hdrlen == 2 && len < 256 )
1458         /* 00 => 1 byte length.  */
1459         ;
1460       else if( hdrlen == 3 && len < 65536 )
1461         /* 01 => 2 byte length.  If len < 256, this is not the most
1462            compact encoding, but it is a correct encoding.  */
1463         ctb |= 1;
1464       else
1465         /* 10 => 4 byte length.  If len < 65536, this is not the most
1466            compact encoding, but it is a correct encoding.  */
1467         ctb |= 2;
1468     }
1469   else
1470     {
1471       if( !len )
1472         /* 11 => Indeterminate length.  */
1473         ctb |= 3;
1474       else if( len < 256 )
1475         /* 00 => 1 byte length.  */
1476         ;
1477       else if( len < 65536 )
1478         /* 01 => 2 byte length.  */
1479         ctb |= 1;
1480       else
1481         /* 10 => 4 byte length.  */
1482         ctb |= 2;
1483     }
1484
1485   if( iobuf_put(out, ctb ) )
1486     return -1;
1487
1488   if( len || hdrlen )
1489     {
1490       if( ctb & 2 )
1491         {
1492           if(iobuf_put(out, len >> 24 ))
1493             return -1;
1494           if(iobuf_put(out, len >> 16 ))
1495             return -1;
1496         }
1497
1498       if( ctb & 3 )
1499         if(iobuf_put(out, len >> 8 ))
1500           return -1;
1501
1502       if( iobuf_put(out, len ) )
1503         return -1;
1504     }
1505
1506   return 0;
1507 }
1508
1509
1510 /* Write a new format header to OUT.
1511
1512    CTB is the ctb.
1513
1514    LEN is the length of the packet's body.  If LEN is 0, then enables
1515    partial body length mode (i.e., the body is of an indeterminant
1516    length) on OUT.  Note: this function cannot be used to generate a
1517    header for a zero length packet.
1518
1519    HDRLEN is the length of the packet's header.  If HDRLEN is 0, the
1520    shortest encoding is chosen based on the length of the packet's
1521    body.  Currently, values other than 0 are not supported.
1522
1523    Returns 0 on success.  */
1524 static int
1525 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1526 {
1527     if( hdrlen )
1528         log_bug("can't cope with hdrlen yet\n");
1529
1530     if( iobuf_put(out, ctb ) )
1531         return -1;
1532     if( !len ) {
1533         iobuf_set_partial_body_length_mode(out, 512 );
1534     }
1535     else {
1536         if( len < 192 ) {
1537             if( iobuf_put(out, len ) )
1538                 return -1;
1539         }
1540         else if( len < 8384 ) {
1541             len -= 192;
1542             if( iobuf_put( out, (len / 256) + 192) )
1543                 return -1;
1544             if( iobuf_put( out, (len % 256) )  )
1545                 return -1;
1546         }
1547         else {
1548             if( iobuf_put( out, 0xff ) )
1549                 return -1;
1550             if( iobuf_put( out, (len >> 24)&0xff ) )
1551                 return -1;
1552             if( iobuf_put( out, (len >> 16)&0xff ) )
1553                 return -1;
1554             if( iobuf_put( out, (len >> 8)&0xff )  )
1555                 return -1;
1556             if( iobuf_put( out, len & 0xff ) )
1557                 return -1;
1558         }
1559     }
1560     return 0;
1561 }