common/ksba-io-support.c

   1 /* kska-io-support.c - Supporting functions for ksba reader and writer
   2  * Copyright (C) 2001-2005, 2007, 2010-2011, 2017  Werner Koch
   3  * Copyright (C) 2006  g10 Code GmbH
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * This file is free software; you can redistribute it and/or modify
   8  * it under the terms of either
   9  *
  10  *   - the GNU Lesser General Public License as published by the Free
  11  *     Software Foundation; either version 3 of the License, or (at
  12  *     your option) any later version.
  13  *
  14  * or
  15  *
  16  *   - the GNU General Public License as published by the Free
  17  *     Software Foundation; either version 2 of the License, or (at
  18  *     your option) any later version.
  19  *
  20  * or both in parallel, as here.
  21  *
  22  * This file is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25  * GNU General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU General Public License
  28  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  29  */
  30
  31 #include <config.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <errno.h>
  36 #include <unistd.h>
  37 #include <time.h>
  38 #include <assert.h>
  39 #include <ksba.h>
  40
  41 #include "util.h"
  42 #include "i18n.h"
  43 #include "ksba-io-support.h"
  44
  45
  46 #ifdef HAVE_DOSISH_SYSTEM
  47   #define LF "\r\n"
  48 #else
  49   #define LF "\n"
  50 #endif
  51
  52
  53 /* Data used by the reader callbacks.  */
  54 struct reader_cb_parm_s
  55 {
  56   estream_t fp;
  57
  58   unsigned char line[1024];
  59   int linelen;
  60   int readpos;
  61   int have_lf;
  62   unsigned long line_counter;
  63
  64   int allow_multi_pem;  /* Allow processing of multiple PEM objects. */
  65   int autodetect;       /* Try to detect the input encoding. */
  66   int assume_pem;       /* Assume input encoding is PEM. */
  67   int assume_base64;    /* Assume input is base64 encoded. */
  68
  69   int identified;
  70   int is_pem;
  71   int is_base64;
  72   int stop_seen;
  73   int might_be_smime;
  74
  75   int eof_seen;
  76
  77   struct {
  78     int idx;
  79     unsigned char val;
  80     int stop_seen;
  81   } base64;
  82 };
  83
  84
  85 /* Data used by the writer callbacks.  */
  86 struct writer_cb_parm_s
  87 {
  88   estream_t stream;    /* Output stream.  */
  89
  90   char *pem_name;      /* Malloced.  */
  91
  92   int wrote_begin;
  93   int did_finish;
  94
  95   struct {
  96     int idx;
  97     int quad_count;
  98     unsigned char radbuf[4];
  99   } base64;
 100
 101 };
 102
 103
 104 /* Context for this module's functions.  */
 105 struct gnupg_ksba_io_s {
 106   union {
 107     struct reader_cb_parm_s rparm;
 108     struct writer_cb_parm_s wparm;
 109   } u;
 110
 111   union {
 112     ksba_reader_t reader;
 113     ksba_writer_t writer;
 114   } u2;
 115 };
 116
 117
 118 /* The base-64 character list */
 119 static char bintoasc[64] =
 120        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 121        "abcdefghijklmnopqrstuvwxyz"
 122        "0123456789+/";
 123 /* The reverse base-64 list */
 124 static unsigned char asctobin[256] = {
 125   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 126   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 127   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 128   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
 129   0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0xff, 0xff,
 130   0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
 131   0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
 132   0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
 133   0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
 134   0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
 135   0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 136   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 137   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 138   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 139   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 140   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 141   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 142   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 143   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 144   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 145   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 146   0xff, 0xff, 0xff, 0xff
 147 };
 148
 149
 150 static int
 151 has_only_base64 (const unsigned char *line, int linelen)
 152 {
 153   if (linelen < 20)
 154     return 0;
 155   for (; linelen; line++, linelen--)
 156     {
 157       if (*line == '\n' || (linelen > 1 && *line == '\r' && line[1] == '\n'))
 158           break;
 159       if ( !strchr (bintoasc, *line) )
 160         return 0;
 161     }
 162   return 1;  /* yes */
 163 }
 164
 165 static int
 166 is_empty_line (const unsigned char *line, int linelen)
 167 {
 168   if (linelen >= 2 && *line == '\r' && line[1] == '\n')
 169     return 1;
 170   if (linelen >= 1 && *line == '\n')
 171     return 1;
 172   return 0;
 173 }
 174
 175
 176 static int
 177 base64_reader_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
 178 {
 179   struct reader_cb_parm_s *parm = cb_value;
 180   size_t n;
 181   int c, c2;
 182
 183   *nread = 0;
 184   if (!buffer)
 185     return -1; /* not supported */
 186
 187  next:
 188   if (!parm->linelen)
 189     {
 190       /* read an entire line or up to the size of the buffer */
 191       parm->line_counter++;
 192       parm->have_lf = 0;
 193       for (n=0; n < DIM(parm->line);)
 194         {
 195           c = es_getc (parm->fp);
 196           if (c == EOF)
 197             {
 198               parm->eof_seen = 1;
 199               if (es_ferror (parm->fp))
 200                 return -1;
 201               break;
 202             }
 203           parm->line[n++] = c;
 204           if (c == '\n')
 205             {
 206               parm->have_lf = 1;
 207               /* Fixme: we need to skip overlong lines while detecting
 208                  the dashed lines */
 209               break;
 210             }
 211         }
 212       parm->linelen = n;
 213       if (!n)
 214         return -1; /* eof */
 215       parm->readpos = 0;
 216     }
 217
 218   if (!parm->identified)
 219     {
 220       if (!parm->autodetect)
 221         {
 222           if (parm->assume_pem)
 223             {
 224               /* wait for the header line */
 225               parm->linelen = parm->readpos = 0;
 226               if (!parm->have_lf
 227                   || strncmp ((char*)parm->line, "-----BEGIN ", 11)
 228                   || !strncmp ((char*)parm->line+11, "PGP ", 4))
 229                 goto next;
 230               parm->is_pem = 1;
 231             }
 232           else if (parm->assume_base64)
 233             parm->is_base64 = 1;
 234         }
 235       else if (parm->line_counter == 1 && !parm->have_lf)
 236         {
 237           /* first line too long - assume DER encoding */
 238           parm->is_pem = 0;
 239         }
 240       else if (parm->line_counter == 1 && parm->linelen && *parm->line == 0x30)
 241         {
 242           /* the very first byte does pretty much look like a SEQUENCE tag*/
 243           parm->is_pem = 0;
 244         }
 245       else if ( parm->have_lf
 246                 && !strncmp ((char*)parm->line, "-----BEGIN ", 11)
 247                 && strncmp ((char *)parm->line+11, "PGP ", 4) )
 248         {
 249           /* Fixme: we must only compare if the line really starts at
 250              the beginning */
 251           parm->is_pem = 1;
 252           parm->linelen = parm->readpos = 0;
 253         }
 254       else if ( parm->have_lf && parm->line_counter == 1
 255                 && parm->linelen >= 13
 256                 && !ascii_memcasecmp (parm->line, "Content-Type:", 13))
 257         { /* might be a S/MIME body */
 258           parm->might_be_smime = 1;
 259           parm->linelen = parm->readpos = 0;
 260           goto next;
 261         }
 262       else if (parm->might_be_smime == 1
 263                && is_empty_line (parm->line, parm->linelen))
 264         {
 265           parm->might_be_smime = 2;
 266           parm->linelen = parm->readpos = 0;
 267           goto next;
 268         }
 269       else if (parm->might_be_smime == 2)
 270         {
 271           parm->might_be_smime = 0;
 272           if ( !has_only_base64 (parm->line, parm->linelen))
 273             {
 274               parm->linelen = parm->readpos = 0;
 275               goto next;
 276             }
 277           parm->is_pem = 1;
 278         }
 279       else
 280         {
 281           parm->linelen = parm->readpos = 0;
 282           goto next;
 283         }
 284       parm->identified = 1;
 285       parm->base64.stop_seen = 0;
 286       parm->base64.idx = 0;
 287     }
 288
 289
 290   n = 0;
 291   if (parm->is_pem || parm->is_base64)
 292     {
 293       if (parm->is_pem && parm->have_lf
 294           && !strncmp ((char*)parm->line, "-----END ", 9))
 295         {
 296           parm->identified = 0;
 297           parm->linelen = parm->readpos = 0;
 298
 299           /* If the caller want to read multiple PEM objects from one
 300              file, we have to reset our internal state and return a
 301              EOF immediately. The caller is the expected to use
 302              ksba_reader_clear to clear the EOF condition and continue
 303              to read.  If we don't want to do that we just return 0
 304              bytes which will force the ksba_reader to skip until
 305              EOF. */
 306           if (parm->allow_multi_pem)
 307             {
 308               parm->identified = 0;
 309               parm->autodetect = 0;
 310               parm->assume_pem = 1;
 311               parm->stop_seen = 0;
 312               return -1; /* Send EOF now. */
 313             }
 314         }
 315       else if (parm->stop_seen)
 316         { /* skip the rest of the line */
 317           parm->linelen = parm->readpos = 0;
 318         }
 319       else
 320         {
 321           int idx = parm->base64.idx;
 322           unsigned char val = parm->base64.val;
 323
 324           while (n < count && parm->readpos < parm->linelen )
 325             {
 326               c = parm->line[parm->readpos++];
 327               if (c == '\n' || c == ' ' || c == '\r' || c == '\t')
 328                 continue;
 329               if (c == '=')
 330                 { /* pad character: stop */
 331                   if (idx == 1)
 332                     buffer[n++] = val;
 333                   parm->stop_seen = 1;
 334                   break;
 335                 }
 336               if( (c = asctobin[(c2=c)]) == 255 )
 337                 {
 338                   log_error (_("invalid radix64 character %02x skipped\n"),
 339                              c2);
 340                   continue;
 341                 }
 342               switch (idx)
 343                 {
 344                 case 0:
 345                   val = c << 2;
 346                   break;
 347                 case 1:
 348                   val |= (c>>4)&3;
 349                   buffer[n++] = val;
 350                   val = (c<<4)&0xf0;
 351                   break;
 352                 case 2:
 353                   val |= (c>>2)&15;
 354                   buffer[n++] = val;
 355                   val = (c<<6)&0xc0;
 356                   break;
 357                 case 3:
 358                   val |= c&0x3f;
 359                   buffer[n++] = val;
 360                   break;
 361                 }
 362               idx = (idx+1) % 4;
 363             }
 364           if (parm->readpos == parm->linelen)
 365             parm->linelen = parm->readpos = 0;
 366
 367           parm->base64.idx = idx;
 368           parm->base64.val = val;
 369         }
 370     }
 371   else
 372     { /* DER encoded */
 373       while (n < count && parm->readpos < parm->linelen)
 374           buffer[n++] = parm->line[parm->readpos++];
 375       if (parm->readpos == parm->linelen)
 376         parm->linelen = parm->readpos = 0;
 377     }
 378
 379   *nread = n;
 380   return 0;
 381 }
 382
 383
 384
 385 static int
 386 simple_reader_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
 387 {
 388   struct reader_cb_parm_s *parm = cb_value;
 389   size_t n;
 390   int c = 0;
 391
 392   *nread = 0;
 393   if (!buffer)
 394     return -1; /* not supported */
 395
 396   for (n=0; n < count; n++)
 397     {
 398       c = es_getc (parm->fp);
 399       if (c == EOF)
 400         {
 401           parm->eof_seen = 1;
 402           if (es_ferror (parm->fp))
 403             return -1;
 404           if (n)
 405             break; /* Return what we have before an EOF.  */
 406           return -1;
 407         }
 408       *(byte *)buffer++ = c;
 409     }
 410
 411   *nread = n;
 412   return 0;
 413 }
 414
 415
 416
 417 \f
 418 static int
 419 base64_writer_cb (void *cb_value, const void *buffer, size_t count)
 420 {
 421   struct writer_cb_parm_s *parm = cb_value;
 422   unsigned char radbuf[4];
 423   int i, c, idx, quad_count;
 424   const unsigned char *p;
 425   estream_t stream = parm->stream;
 426
 427   if (!count)
 428     return 0;
 429
 430   if (!parm->wrote_begin)
 431     {
 432       if (parm->pem_name)
 433         {
 434           es_fputs ("-----BEGIN ", stream);
 435           es_fputs (parm->pem_name, stream);
 436           es_fputs ("-----\n", stream);
 437         }
 438       parm->wrote_begin = 1;
 439       parm->base64.idx = 0;
 440       parm->base64.quad_count = 0;
 441     }
 442
 443   idx = parm->base64.idx;
 444   quad_count = parm->base64.quad_count;
 445   for (i=0; i < idx; i++)
 446     radbuf[i] = parm->base64.radbuf[i];
 447
 448   for (p=buffer; count; p++, count--)
 449     {
 450       radbuf[idx++] = *p;
 451       if (idx > 2)
 452         {
 453           idx = 0;
 454           c = bintoasc[(*radbuf >> 2) & 077];
 455           es_putc (c, stream);
 456           c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
 457           es_putc (c, stream);
 458           c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
 459           es_putc (c, stream);
 460           c = bintoasc[radbuf[2]&077];
 461           es_putc (c, stream);
 462           if (++quad_count >= (64/4))
 463             {
 464               es_fputs (LF, stream);
 465               quad_count = 0;
 466             }
 467         }
 468     }
 469   for (i=0; i < idx; i++)
 470     parm->base64.radbuf[i] = radbuf[i];
 471   parm->base64.idx = idx;
 472   parm->base64.quad_count = quad_count;
 473
 474   return es_ferror (stream)? gpg_error_from_syserror () : 0;
 475 }
 476
 477
 478 /* This callback is only used in stream mode.  However, we don't
 479    restrict it to this.  */
 480 static int
 481 plain_writer_cb (void *cb_value, const void *buffer, size_t count)
 482 {
 483   struct writer_cb_parm_s *parm = cb_value;
 484   estream_t stream = parm->stream;
 485
 486   if (!count)
 487     return 0;
 488
 489   es_write (stream, buffer, count, NULL);
 490
 491   return es_ferror (stream)? gpg_error_from_syserror () : 0;
 492 }
 493
 494
 495 static int
 496 base64_finish_write (struct writer_cb_parm_s *parm)
 497 {
 498   unsigned char *radbuf;
 499   int c, idx, quad_count;
 500   estream_t stream = parm->stream;
 501
 502   if (!parm->wrote_begin)
 503     return 0; /* Nothing written or we are not called in base-64 mode. */
 504
 505   /* flush the base64 encoding */
 506   idx = parm->base64.idx;
 507   quad_count = parm->base64.quad_count;
 508   if (idx)
 509     {
 510       radbuf = parm->base64.radbuf;
 511
 512       c = bintoasc[(*radbuf>>2)&077];
 513       es_putc (c, stream);
 514       if (idx == 1)
 515         {
 516           c = bintoasc[((*radbuf << 4) & 060) & 077];
 517           es_putc (c, stream);
 518           es_putc ('=', stream);
 519           es_putc ('=', stream);
 520         }
 521       else
 522         {
 523           c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
 524           es_putc (c, stream);
 525           c = bintoasc[((radbuf[1] << 2) & 074) & 077];
 526           es_putc (c, stream);
 527           es_putc ('=', stream);
 528
 529         }
 530       if (++quad_count >= (64/4))
 531         {
 532           es_fputs (LF, stream);
 533           quad_count = 0;
 534         }
 535     }
 536
 537   if (quad_count)
 538     es_fputs (LF, stream);
 539
 540   if (parm->pem_name)
 541     {
 542       es_fputs ("-----END ", stream);
 543       es_fputs (parm->pem_name, stream);
 544       es_fputs ("-----\n", stream);
 545     }
 546
 547   return es_ferror (stream)? gpg_error_from_syserror () : 0;
 548 }
 549
 550
 551
 552 \f
 553 /* Create a reader for the stream FP.  FLAGS can be used to specify
 554  * the expected input encoding.
 555  *
 556  * The function returns a gnupg_ksba_io_t object which must be passed to
 557  * the gpgme_destroy_reader function.  The created ksba_reader_t
 558  * object is stored at R_READER - the caller must not call the
 559  * ksba_reader_release function on.
 560  *
 561  * The supported flags are:
 562  *
 563  * GNUPG_KSBA_IO_PEM        - Assume the input is PEM encoded
 564  * GNUPG_KSBA_IO_BASE64     - Assume the input is Base64 encoded.
 565  * GNUPG_KSBA_IO_AUTODETECT - The reader tries to detect the encoding.
 566  * GNUPG_KSBA_IO_MULTIPEM   - The reader expects that the caller uses
 567  *                            ksba_reader_clear after EOF until no more
 568  *                            objects were found.
 569  *
 570  * Note that the PEM flag has a higher priority than the BASE64 flag
 571  * which in turn has a gight priority than the AUTODETECT flag.
 572  */
 573 gpg_error_t
 574 gnupg_ksba_create_reader (gnupg_ksba_io_t *ctx,
 575                           unsigned int flags, estream_t fp,
 576                           ksba_reader_t *r_reader)
 577 {
 578   int rc;
 579   ksba_reader_t r;
 580
 581   *r_reader = NULL;
 582   *ctx = xtrycalloc (1, sizeof **ctx);
 583   if (!*ctx)
 584     return out_of_core ();
 585   (*ctx)->u.rparm.allow_multi_pem = !!(flags & GNUPG_KSBA_IO_MULTIPEM);
 586
 587   rc = ksba_reader_new (&r);
 588   if (rc)
 589     {
 590       xfree (*ctx); *ctx = NULL;
 591       return rc;
 592     }
 593
 594   (*ctx)->u.rparm.fp = fp;
 595   if ((flags & GNUPG_KSBA_IO_PEM))
 596     {
 597       (*ctx)->u.rparm.assume_pem = 1;
 598       (*ctx)->u.rparm.assume_base64 = 1;
 599       rc = ksba_reader_set_cb (r, base64_reader_cb, &(*ctx)->u.rparm);
 600     }
 601   else if ((flags & GNUPG_KSBA_IO_BASE64))
 602     {
 603       (*ctx)->u.rparm.assume_base64 = 1;
 604       rc = ksba_reader_set_cb (r, base64_reader_cb, &(*ctx)->u.rparm);
 605     }
 606   else if ((flags & GNUPG_KSBA_IO_AUTODETECT))
 607     {
 608       (*ctx)->u.rparm.autodetect = 1;
 609       rc = ksba_reader_set_cb (r, base64_reader_cb, &(*ctx)->u.rparm);
 610     }
 611   else
 612       rc = ksba_reader_set_cb (r, simple_reader_cb, &(*ctx)->u.rparm);
 613
 614   if (rc)
 615     {
 616       ksba_reader_release (r);
 617       xfree (*ctx); *ctx = NULL;
 618       return rc;
 619     }
 620
 621   (*ctx)->u2.reader = r;
 622   *r_reader = r;
 623   return 0;
 624 }
 625
 626
 627 /* Return True if an EOF as been seen.  */
 628 int
 629 gnupg_ksba_reader_eof_seen (gnupg_ksba_io_t ctx)
 630 {
 631   return ctx && ctx->u.rparm.eof_seen;
 632 }
 633
 634
 635 /* Destroy a reader object.  */
 636 void
 637 gnupg_ksba_destroy_reader (gnupg_ksba_io_t ctx)
 638 {
 639   if (!ctx)
 640     return;
 641
 642   ksba_reader_release (ctx->u2.reader);
 643   xfree (ctx);
 644 }
 645
 646
 647 \f
 648 /* Create a writer for the given STREAM.  Depending on FLAGS an output
 649  * encoding is chosen.  In PEM mode PEM_NAME is used for the header
 650  * and footer lines; if PEM_NAME is NULL the string "CMS OBJECT" is
 651  * used.
 652  *
 653  * The function returns a gnupg_ksba_io_t object which must be passed to
 654  * the gpgme_destroy_writer function.  The created ksba_writer_t
 655  * object is stored at R_WRITER - the caller must not call the
 656  * ksba_reader_release function on it.
 657  *
 658  * The supported flags are:
 659  *
 660  * GNUPG_KSBA_IO_PEM    - Write output as PEM
 661  * GNUPG_KSBA_IO_BASE64 - Write output as plain Base64; note that the PEM
 662  *                        flag overrides this flag.
 663  *
 664  */
 665 gpg_error_t
 666 gnupg_ksba_create_writer (gnupg_ksba_io_t *ctx, unsigned int flags,
 667                           const char *pem_name, estream_t stream,
 668                           ksba_writer_t *r_writer)
 669 {
 670   int rc;
 671   ksba_writer_t w;
 672
 673   *r_writer = NULL;
 674   *ctx = xtrycalloc (1, sizeof **ctx);
 675   if (!*ctx)
 676     return gpg_error_from_syserror ();
 677
 678   rc = ksba_writer_new (&w);
 679   if (rc)
 680     {
 681       xfree (*ctx); *ctx = NULL;
 682       return rc;
 683     }
 684
 685   if ((flags & GNUPG_KSBA_IO_PEM) || (flags & GNUPG_KSBA_IO_BASE64))
 686     {
 687       (*ctx)->u.wparm.stream = stream;
 688       if ((flags & GNUPG_KSBA_IO_PEM))
 689         {
 690           (*ctx)->u.wparm.pem_name = xtrystrdup (pem_name
 691                                                  ? pem_name
 692                                                  : "CMS OBJECT");
 693           if (!(*ctx)->u.wparm.pem_name)
 694             {
 695               rc = gpg_error_from_syserror ();
 696               ksba_writer_release (w);
 697               xfree (*ctx); *ctx = NULL;
 698               return rc;
 699             }
 700         }
 701       rc = ksba_writer_set_cb (w, base64_writer_cb, &(*ctx)->u.wparm);
 702     }
 703   else if (stream)
 704     {
 705       (*ctx)->u.wparm.stream = stream;
 706       rc = ksba_writer_set_cb (w, plain_writer_cb, &(*ctx)->u.wparm);
 707     }
 708   else
 709     rc = gpg_error (GPG_ERR_INV_ARG);
 710
 711   if (rc)
 712     {
 713       ksba_writer_release (w);
 714       xfree (*ctx); *ctx = NULL;
 715       return rc;
 716     }
 717
 718   (*ctx)->u2.writer = w;
 719   *r_writer = w;
 720   return 0;
 721 }
 722
 723
 724 /* Flush a writer.  This is for example required to write the padding
 725  * or the PEM footer.  */
 726 gpg_error_t
 727 gnupg_ksba_finish_writer (gnupg_ksba_io_t ctx)
 728 {
 729   struct writer_cb_parm_s *parm;
 730
 731   if (!ctx)
 732     return gpg_error (GPG_ERR_INV_VALUE);
 733   parm = &ctx->u.wparm;
 734   if (parm->did_finish)
 735     return 0; /* Already done. */
 736   parm->did_finish = 1;
 737   if (!parm->stream)
 738     return 0; /* Callback was not used.  */
 739   return base64_finish_write (parm);
 740 }
 741
 742
 743 /* Destroy a writer object.  */
 744 void
 745 gnupg_ksba_destroy_writer (gnupg_ksba_io_t ctx)
 746 {
 747   if (!ctx)
 748     return;
 749
 750   ksba_writer_release (ctx->u2.writer);
 751   xfree (ctx->u.wparm.pem_name);
 752   xfree (ctx);
 753 }