gpg: Avoid directly twiddling bits.
[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 /* Turn the notation described by the string STRING into a notation.
1066
1067    STRING has the form:
1068
1069      - -name - Delete the notation.
1070      - name@domain.name=value - Normal notation
1071      - !name@domain.name=value - Notation with critical bit set.
1072
1073    The caller must free the result using free_notation().  */
1074 struct notation *
1075 string_to_notation(const char *string,int is_utf8)
1076 {
1077   const char *s;
1078   int saw_at=0;
1079   struct notation *notation;
1080
1081   notation=xmalloc_clear(sizeof(*notation));
1082
1083   if(*string=='-')
1084     {
1085       notation->flags.ignore=1;
1086       string++;
1087     }
1088
1089   if(*string=='!')
1090     {
1091       notation->flags.critical=1;
1092       string++;
1093     }
1094
1095   /* If and when the IETF assigns some official name tags, we'll have
1096      to add them here. */
1097
1098   for( s=string ; *s != '='; s++ )
1099     {
1100       if( *s=='@')
1101         saw_at++;
1102
1103       /* -notationname is legal without an = sign */
1104       if(!*s && notation->flags.ignore)
1105         break;
1106
1107       if( !*s || !isascii (*s) || (!isgraph(*s) && !isspace(*s)) )
1108         {
1109           log_error(_("a notation name must have only printable characters"
1110                       " or spaces, and end with an '='\n") );
1111           goto fail;
1112         }
1113     }
1114
1115   notation->name=xmalloc((s-string)+1);
1116   strncpy(notation->name,string,s-string);
1117   notation->name[s-string]='\0';
1118
1119   if(!saw_at && !opt.expert)
1120     {
1121       log_error(_("a user notation name must contain the '@' character\n"));
1122       goto fail;
1123     }
1124
1125   if (saw_at > 1)
1126     {
1127       log_error(_("a notation name must not contain more than"
1128                   " one '@' character\n"));
1129       goto fail;
1130     }
1131
1132   if(*s)
1133     {
1134       const char *i=s+1;
1135       int highbit=0;
1136
1137       /* we only support printable text - therefore we enforce the use
1138          of only printable characters (an empty value is valid) */
1139       for(s++; *s ; s++ )
1140         {
1141           if ( !isascii (*s) )
1142             highbit=1;
1143           else if (iscntrl(*s))
1144             {
1145               log_error(_("a notation value must not use any"
1146                           " control characters\n"));
1147               goto fail;
1148             }
1149         }
1150
1151       if(!highbit || is_utf8)
1152         notation->value=xstrdup(i);
1153       else
1154         notation->value=native_to_utf8(i);
1155     }
1156
1157   return notation;
1158
1159  fail:
1160   free_notation(notation);
1161   return NULL;
1162 }
1163
1164 /* Return all of the notations stored in the signature SIG.  The
1165    caller must free them using free_notation().  */
1166 struct notation *
1167 sig_to_notation(PKT_signature *sig)
1168 {
1169   const byte *p;
1170   size_t len;
1171   int seq=0,crit;
1172   struct notation *list=NULL;
1173
1174   /* See RFC 4880, 5.2.3.16 for the format of notation data.  In
1175      short, a notation has:
1176
1177        - 4 bytes of flags
1178        - 2 byte name length (n1)
1179        - 2 byte value length (n2)
1180        - n1 bytes of name data
1181        - n2 bytes of value data
1182    */
1183   while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_NOTATION,&len,&seq,&crit)))
1184     {
1185       int n1,n2;
1186       struct notation *n=NULL;
1187
1188       if(len<8)
1189         {
1190           log_info(_("WARNING: invalid notation data found\n"));
1191           continue;
1192         }
1193
1194       /* name length.  */
1195       n1=(p[4]<<8)|p[5];
1196       /* value length.  */
1197       n2=(p[6]<<8)|p[7];
1198
1199       if(8+n1+n2!=len)
1200         {
1201           log_info(_("WARNING: invalid notation data found\n"));
1202           continue;
1203         }
1204
1205       n=xmalloc_clear(sizeof(*n));
1206       n->name=xmalloc(n1+1);
1207
1208       memcpy(n->name,&p[8],n1);
1209       n->name[n1]='\0';
1210
1211       if(p[0]&0x80)
1212         /* The value is human-readable.  */
1213         {
1214           n->value=xmalloc(n2+1);
1215           memcpy(n->value,&p[8+n1],n2);
1216           n->value[n2]='\0';
1217         }
1218       else
1219         /* Binary data.  */
1220         {
1221           n->bdat=xmalloc(n2);
1222           n->blen=n2;
1223           memcpy(n->bdat,&p[8+n1],n2);
1224
1225           n->value=xmalloc(2+strlen(_("not human readable"))+2+1);
1226           strcpy(n->value,"[ ");
1227           strcat(n->value,_("not human readable"));
1228           strcat(n->value," ]");
1229         }
1230
1231       n->flags.critical=crit;
1232
1233       n->next=list;
1234       list=n;
1235     }
1236
1237   return list;
1238 }
1239
1240 /* Release the resources associated with the *list* of notations.  To
1241    release a single notation, make sure that notation->next is
1242    NULL.  */
1243 void
1244 free_notation(struct notation *notation)
1245 {
1246   while(notation)
1247     {
1248       struct notation *n=notation;
1249
1250       xfree(n->name);
1251       xfree(n->value);
1252       xfree(n->altvalue);
1253       xfree(n->bdat);
1254       notation=n->next;
1255       xfree(n);
1256     }
1257 }
1258
1259 /* Serialize the signature packet (RFC 4880, Section 5.2) described by
1260    SIG and write it to OUT.  */
1261 static int
1262 do_signature( IOBUF out, int ctb, PKT_signature *sig )
1263 {
1264   int rc = 0;
1265   int n, i;
1266   IOBUF a = iobuf_temp();
1267
1268   log_assert (ctb_pkttype (ctb) == PKT_SIGNATURE);
1269
1270   if ( !sig->version || sig->version == 3)
1271     {
1272       iobuf_put( a, 3 );
1273
1274       /* Version 3 packets don't support subpackets.  */
1275       log_assert (! sig->hashed);
1276       log_assert (! sig->unhashed);
1277     }
1278   else
1279     iobuf_put( a, sig->version );
1280   if ( sig->version < 4 )
1281     iobuf_put (a, 5 ); /* Constant */
1282   iobuf_put (a, sig->sig_class );
1283   if ( sig->version < 4 )
1284     {
1285       write_32(a, sig->timestamp );
1286       write_32(a, sig->keyid[0] );
1287       write_32(a, sig->keyid[1] );
1288     }
1289   iobuf_put(a, sig->pubkey_algo );
1290   iobuf_put(a, sig->digest_algo );
1291   if ( sig->version >= 4 )
1292     {
1293       size_t nn;
1294       /* Timestamp and keyid must have been packed into the subpackets
1295          prior to the call of this function, because these subpackets
1296          are hashed. */
1297       nn = sig->hashed? sig->hashed->len : 0;
1298       write_16(a, nn);
1299       if (nn)
1300         iobuf_write( a, sig->hashed->data, nn );
1301       nn = sig->unhashed? sig->unhashed->len : 0;
1302       write_16(a, nn);
1303       if (nn)
1304         iobuf_write( a, sig->unhashed->data, nn );
1305     }
1306   iobuf_put(a, sig->digest_start[0] );
1307   iobuf_put(a, sig->digest_start[1] );
1308   n = pubkey_get_nsig( sig->pubkey_algo );
1309   if ( !n )
1310     write_fake_data( a, sig->data[0] );
1311   for (i=0; i < n && !rc ; i++ )
1312     rc = gpg_mpi_write (a, sig->data[i] );
1313
1314   if (!rc)
1315     {
1316       if ( is_RSA(sig->pubkey_algo) && sig->version < 4 )
1317         write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
1318       else
1319         write_header(out, ctb, iobuf_get_temp_length(a) );
1320       rc = iobuf_write_temp( out, a );
1321     }
1322
1323   iobuf_close(a);
1324   return rc;
1325 }
1326
1327
1328 /* Serialize the one-pass signature packet (RFC 4880, Section 5.4)
1329    described by OPS and write it to OUT.  */
1330 static int
1331 do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
1332 {
1333   log_assert (ctb_pkttype (ctb) == PKT_ONEPASS_SIG);
1334
1335     write_header(out, ctb, 4 + 8 + 1);
1336
1337     iobuf_put (out, 3);  /* Version.  */
1338     iobuf_put(out, ops->sig_class );
1339     iobuf_put(out, ops->digest_algo );
1340     iobuf_put(out, ops->pubkey_algo );
1341     write_32(out, ops->keyid[0] );
1342     write_32(out, ops->keyid[1] );
1343     iobuf_put(out, ops->last );
1344
1345     return 0;
1346 }
1347
1348
1349 /* Write a 16-bit quantity to OUT in big endian order.  */
1350 static int
1351 write_16(IOBUF out, u16 a)
1352 {
1353     iobuf_put(out, a>>8);
1354     if( iobuf_put(out,a) )
1355         return -1;
1356     return 0;
1357 }
1358
1359 /* Write a 32-bit quantity to OUT in big endian order.  */
1360 static int
1361 write_32(IOBUF out, u32 a)
1362 {
1363     iobuf_put(out, a>> 24);
1364     iobuf_put(out, a>> 16);
1365     iobuf_put(out, a>> 8);
1366     return iobuf_put(out, a);
1367 }
1368
1369
1370 /****************
1371  * calculate the length of a header.
1372  *
1373  * LEN is the length of the packet's body.  NEW_CTB is whether we are
1374  * using a new or old format packet.
1375  *
1376  * This function does not handle indeterminate lengths or partial body
1377  * lengths.  (If you pass LEN as 0, then this function assumes you
1378  * really mean an empty body.)
1379  */
1380 static int
1381 calc_header_length( u32 len, int new_ctb )
1382 {
1383     if( new_ctb ) {
1384         if( len < 192 )
1385             return 2;
1386         if( len < 8384 )
1387             return 3;
1388         else
1389             return 6;
1390     }
1391     if( len < 256 )
1392         return 2;
1393     if( len < 65536 )
1394         return 3;
1395
1396     return 5;
1397 }
1398
1399 /****************
1400  * Write the CTB and the packet length
1401  */
1402 static int
1403 write_header( IOBUF out, int ctb, u32 len )
1404 {
1405     return write_header2( out, ctb, len, 0 );
1406 }
1407
1408
1409 static int
1410 write_sign_packet_header (IOBUF out, int ctb, u32 len)
1411 {
1412   (void)ctb;
1413
1414   /* Work around a bug in the pgp read function for signature packets,
1415      which are not correctly coded and silently assume at some point 2
1416      byte length headers.*/
1417   iobuf_put (out, 0x89 );
1418   iobuf_put (out, len >> 8 );
1419   return iobuf_put (out, len) == -1 ? -1:0;
1420 }
1421
1422 /****************
1423  * Write a packet header to OUT.
1424  *
1425  * CTB is the ctb.  It determines whether a new or old format packet
1426  * header should be written.  The length field is adjusted, but the
1427  * CTB is otherwise written out as is.
1428  *
1429  * LEN is the length of the packet's body.
1430  *
1431  * If HDRLEN is set, then we don't necessarily use the most efficient
1432  * encoding to store LEN, but the specified length.  (If this is not
1433  * possible, this is a bug.)  In this case, LEN=0 means a 0 length
1434  * packet.  Note: setting HDRLEN is only supported for old format
1435  * packets!
1436  *
1437  * If HDRLEN is not set, then the shortest encoding is used.  In this
1438  * case, LEN=0 means the body has an indeterminate length and a
1439  * partial body length header (if a new format packet) or an
1440  * indeterminate length header (if an old format packet) is written
1441  * out.  Further, if using partial body lengths, this enables partial
1442  * body length mode on OUT.
1443  */
1444 static int
1445 write_header2( IOBUF out, int ctb, u32 len, int hdrlen )
1446 {
1447   if (ctb_new_format_p (ctb))
1448     return write_new_header( out, ctb, len, hdrlen );
1449
1450   /* An old format packet.  Refer to RFC 4880, Section 4.2.1 to
1451      understand how lengths are encoded in this case.  */
1452
1453   log_assert (hdrlen == 0 || hdrlen == 2 || hdrlen == 3 || hdrlen == 5);
1454
1455   if (hdrlen)
1456     /* Header length is given.  */
1457     {
1458       if( hdrlen == 2 && len < 256 )
1459         /* 00 => 1 byte length.  */
1460         ;
1461       else if( hdrlen == 3 && len < 65536 )
1462         /* 01 => 2 byte length.  If len < 256, this is not the most
1463            compact encoding, but it is a correct encoding.  */
1464         ctb |= 1;
1465       else
1466         /* 10 => 4 byte length.  If len < 65536, this is not the most
1467            compact encoding, but it is a correct encoding.  */
1468         ctb |= 2;
1469     }
1470   else
1471     {
1472       if( !len )
1473         /* 11 => Indeterminate length.  */
1474         ctb |= 3;
1475       else if( len < 256 )
1476         /* 00 => 1 byte length.  */
1477         ;
1478       else if( len < 65536 )
1479         /* 01 => 2 byte length.  */
1480         ctb |= 1;
1481       else
1482         /* 10 => 4 byte length.  */
1483         ctb |= 2;
1484     }
1485
1486   if( iobuf_put(out, ctb ) )
1487     return -1;
1488
1489   if( len || hdrlen )
1490     {
1491       if( ctb & 2 )
1492         {
1493           if(iobuf_put(out, len >> 24 ))
1494             return -1;
1495           if(iobuf_put(out, len >> 16 ))
1496             return -1;
1497         }
1498
1499       if( ctb & 3 )
1500         if(iobuf_put(out, len >> 8 ))
1501           return -1;
1502
1503       if( iobuf_put(out, len ) )
1504         return -1;
1505     }
1506
1507   return 0;
1508 }
1509
1510
1511 /* Write a new format header to OUT.
1512
1513    CTB is the ctb.
1514
1515    LEN is the length of the packet's body.  If LEN is 0, then enables
1516    partial body length mode (i.e., the body is of an indeterminant
1517    length) on OUT.  Note: this function cannot be used to generate a
1518    header for a zero length packet.
1519
1520    HDRLEN is the length of the packet's header.  If HDRLEN is 0, the
1521    shortest encoding is chosen based on the length of the packet's
1522    body.  Currently, values other than 0 are not supported.
1523
1524    Returns 0 on success.  */
1525 static int
1526 write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
1527 {
1528     if( hdrlen )
1529         log_bug("can't cope with hdrlen yet\n");
1530
1531     if( iobuf_put(out, ctb ) )
1532         return -1;
1533     if( !len ) {
1534         iobuf_set_partial_body_length_mode(out, 512 );
1535     }
1536     else {
1537         if( len < 192 ) {
1538             if( iobuf_put(out, len ) )
1539                 return -1;
1540         }
1541         else if( len < 8384 ) {
1542             len -= 192;
1543             if( iobuf_put( out, (len / 256) + 192) )
1544                 return -1;
1545             if( iobuf_put( out, (len % 256) )  )
1546                 return -1;
1547         }
1548         else {
1549             if( iobuf_put( out, 0xff ) )
1550                 return -1;
1551             if( iobuf_put( out, (len >> 24)&0xff ) )
1552                 return -1;
1553             if( iobuf_put( out, (len >> 16)&0xff ) )
1554                 return -1;
1555             if( iobuf_put( out, (len >> 8)&0xff )  )
1556                 return -1;
1557             if( iobuf_put( out, len & 0xff ) )
1558                 return -1;
1559         }
1560     }
1561     return 0;
1562 }