g10/call-dirmngr.c

   1 /* call-dirmngr.c - GPG operations to the Dirmngr.
   2  * Copyright (C) 2011 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <unistd.h>
  26 #include <time.h>
  27 #include <assert.h>
  28 #ifdef HAVE_LOCALE_H
  29 # include <locale.h>
  30 #endif
  31
  32 #include "gpg.h"
  33 #include <assuan.h>
  34 #include "util.h"
  35 #include "membuf.h"
  36 #include "options.h"
  37 #include "i18n.h"
  38 #include "asshelp.h"
  39 #include "keyserver.h"
  40 #include "call-dirmngr.h"
  41
  42
  43 /* Parameter structure used to gather status info.  */
  44 struct ks_status_parm_s
  45 {
  46   char *source;
  47 };
  48
  49
  50 /* Parameter structure used with the KS_SEARCH command.  */
  51 struct ks_search_parm_s
  52 {
  53   gpg_error_t lasterr;  /* Last error code.  */
  54   membuf_t saveddata;   /* Buffer to build complete lines.  */
  55   char *helpbuf;        /* NULL or malloced buffer.  */
  56   size_t helpbufsize;   /* Allocated size of HELPBUF.  */
  57   gpg_error_t (*data_cb)(void*, int, char*);  /* Callback.  */
  58   void *data_cb_value;  /* First argument for DATA_CB.  */
  59   struct ks_status_parm_s *stparm; /* Link to the status parameter.  */
  60 };
  61
  62
  63 /* Parameter structure used with the KS_GET command.  */
  64 struct ks_get_parm_s
  65 {
  66   estream_t memfp;
  67 };
  68
  69
  70 /* Parameter structure used with the KS_PUT command.  */
  71 struct ks_put_parm_s
  72 {
  73   assuan_context_t ctx;
  74   kbnode_t keyblock;  /* The optional keyblock.  */
  75   const void *data;   /* The key in OpenPGP binary format.  */
  76   size_t datalen;     /* The length of DATA.  */
  77 };
  78
  79
  80 /* Data used to associate an session with dirmngr contexts.  We can't
  81    use a simple one to one mapping because we sometimes need two
  82    connections to the dirmngr; for example while doing a listing and
  83    being in a data callback we may want to retrieve a key.  The local
  84    dirmngr data takes care of this.  At the end of the session the
  85    function dirmngr_deinit_session_data is called by gpg.c to cleanup
  86    these resources.  Note that gpg.h defines a typedef dirmngr_local_t
  87    for this structure. */
  88 struct dirmngr_local_s
  89 {
  90   /* Link to other contexts which are used simultaneously.  */
  91   struct dirmngr_local_s *next;
  92
  93   /* The active Assuan context. */
  94   assuan_context_t ctx;
  95
  96   /* Flag set to true while an operation is running on CTX.  */
  97   int is_active;
  98 };
  99
 100
 101 \f
 102 /* Deinitialize all session data of dirmngr pertaining to CTRL.  */
 103 void
 104 gpg_dirmngr_deinit_session_data (ctrl_t ctrl)
 105 {
 106   dirmngr_local_t dml;
 107
 108   while ((dml = ctrl->dirmngr_local))
 109     {
 110       ctrl->dirmngr_local = dml->next;
 111       if (dml->is_active)
 112         log_error ("oops: trying to cleanup an active dirmngr context\n");
 113       else
 114         assuan_release (dml->ctx);
 115       xfree (dml);
 116     }
 117 }
 118
 119
 120 /* Try to connect to the Dirmngr via a socket or spawn it if possible.
 121    Handle the server's initial greeting and set global options.  */
 122 static gpg_error_t
 123 create_context (ctrl_t ctrl, assuan_context_t *r_ctx)
 124 {
 125   gpg_error_t err;
 126   assuan_context_t ctx;
 127
 128   *r_ctx = NULL;
 129   err = start_new_dirmngr (&ctx,
 130                            GPG_ERR_SOURCE_DEFAULT,
 131                            opt.homedir,
 132                            opt.dirmngr_program,
 133                            opt.autostart, opt.verbose, DBG_ASSUAN,
 134                            NULL /*gpg_status2*/, ctrl);
 135   if (!opt.autostart && gpg_err_code (err) == GPG_ERR_NO_DIRMNGR)
 136     {
 137       static int shown;
 138
 139       if (!shown)
 140         {
 141           shown = 1;
 142           log_info (_("no dirmngr running in this session\n"));
 143         }
 144     }
 145   else if (!err)
 146     {
 147       keyserver_spec_t ksi;
 148
 149       /* Tell the dirmngr that we want to collect audit event. */
 150       /* err = assuan_transact (agent_ctx, "OPTION audit-events=1", */
 151       /*                        NULL, NULL, NULL, NULL, NULL, NULL); */
 152
 153       /* Set all configured keyservers.  We clear existing keyservers
 154          so that any keyserver configured in GPG overrides keyservers
 155          possibly still configured in Dirmngr for the session (Note
 156          that the keyserver list of a session in Dirmngr survives a
 157          RESET. */
 158       for (ksi = opt.keyserver; !err && ksi; ksi = ksi->next)
 159         {
 160           char *line;
 161
 162           line = xtryasprintf ("KEYSERVER%s %s",
 163                                ksi == opt.keyserver? " --clear":"", ksi->uri);
 164           if (!line)
 165             err = gpg_error_from_syserror ();
 166           else
 167             {
 168               err = assuan_transact (ctx, line,
 169                                      NULL, NULL, NULL, NULL, NULL, NULL);
 170               xfree (line);
 171             }
 172         }
 173     }
 174
 175   if (err)
 176     assuan_release (ctx);
 177   else
 178     {
 179       /* audit_log_ok (ctrl->audit, AUDIT_DIRMNGR_READY, err); */
 180       *r_ctx = ctx;
 181     }
 182
 183   return err;
 184 }
 185
 186
 187 /* Get a context for accessing dirmngr.  If no context is available a
 188    new one is created and - if required - dirmngr started.  On success
 189    an assuan context is stored at R_CTX.  This context may only be
 190    released by means of close_context.  Note that NULL is stored at
 191    R_CTX on error.  */
 192 static gpg_error_t
 193 open_context (ctrl_t ctrl, assuan_context_t *r_ctx)
 194 {
 195   gpg_error_t err;
 196   dirmngr_local_t dml;
 197
 198   *r_ctx = NULL;
 199   for (;;)
 200     {
 201       for (dml = ctrl->dirmngr_local; dml && dml->is_active; dml = dml->next)
 202         ;
 203       if (dml)
 204         {
 205           /* Found an inactive local session - return that.  */
 206           assert (!dml->is_active);
 207           dml->is_active = 1;
 208           *r_ctx = dml->ctx;
 209           return 0;
 210         }
 211
 212       dml = xtrycalloc (1, sizeof *dml);
 213       if (!dml)
 214         return gpg_error_from_syserror ();
 215       err = create_context (ctrl, &dml->ctx);
 216       if (err)
 217         {
 218           xfree (dml);
 219           return err;
 220         }
 221       /* To be on the nPth thread safe site we need to add it to a
 222          list; this is far easier than to have a lock for this
 223          function.  It should not happen anyway but the code is free
 224          because we need it for the is_active check above.  */
 225       dml->next = ctrl->dirmngr_local;
 226       ctrl->dirmngr_local = dml;
 227     }
 228 }
 229
 230
 231 /* Close the assuan context CTX or return it to a pool of unused
 232    contexts.  If CTX is NULL, the function does nothing.  */
 233 static void
 234 close_context (ctrl_t ctrl, assuan_context_t ctx)
 235 {
 236   dirmngr_local_t dml;
 237
 238   if (!ctx)
 239     return;
 240
 241   for (dml = ctrl->dirmngr_local; dml; dml = dml->next)
 242     {
 243       if (dml->ctx == ctx)
 244         {
 245           if (!dml->is_active)
 246             log_fatal ("closing inactive dirmngr context %p\n", ctx);
 247           dml->is_active = 0;
 248           return;
 249         }
 250     }
 251   log_fatal ("closing unknown dirmngr ctx %p\n", ctx);
 252 }
 253
 254
 255 \f
 256 /* Status callback for ks_get and ks_search.  */
 257 static gpg_error_t
 258 ks_status_cb (void *opaque, const char *line)
 259 {
 260   struct ks_status_parm_s *parm = opaque;
 261   gpg_error_t err = 0;
 262   const char *s;
 263
 264   if ((s = has_leading_keyword (line, "SOURCE")))
 265     {
 266       if (!parm->source)
 267         {
 268           parm->source = xtrystrdup (s);
 269           if (!parm->source)
 270             err = gpg_error_from_syserror ();
 271         }
 272     }
 273
 274   return err;
 275 }
 276
 277
 278 \f
 279 /* Data callback for the KS_SEARCH command. */
 280 static gpg_error_t
 281 ks_search_data_cb (void *opaque, const void *data, size_t datalen)
 282 {
 283   gpg_error_t err = 0;
 284   struct ks_search_parm_s *parm = opaque;
 285   const char *line, *s;
 286   size_t rawlen, linelen;
 287   char fixedbuf[256];
 288
 289   if (parm->lasterr)
 290     return 0;
 291
 292   if (parm->stparm->source)
 293     {
 294       err = parm->data_cb (parm->data_cb_value, 1, parm->stparm->source);
 295       if (err)
 296         {
 297           parm->lasterr = err;
 298           return err;
 299         }
 300       /* Clear it so that we won't get back here unless the server
 301          accidentally sends a second source status line.  Note that
 302          will not see all accidentally sent source lines because it
 303          depends on whether data lines have been send in between.  */
 304       xfree (parm->stparm->source);
 305       parm->stparm->source = NULL;
 306     }
 307
 308   if (!data)
 309     return 0;  /* Ignore END commands.  */
 310
 311   put_membuf (&parm->saveddata, data, datalen);
 312
 313  again:
 314   line = peek_membuf (&parm->saveddata, &rawlen);
 315   if (!line)
 316     {
 317       parm->lasterr = gpg_error_from_syserror ();
 318       return parm->lasterr; /* Tell the server about our problem.  */
 319     }
 320   if ((s = memchr (line, '\n', rawlen)))
 321     {
 322       linelen = s - line;  /* That is the length excluding the LF.  */
 323       if (linelen + 1 < sizeof fixedbuf)
 324         {
 325           /* We can use the static buffer.  */
 326           memcpy (fixedbuf, line, linelen);
 327           fixedbuf[linelen] = 0;
 328           if (linelen && fixedbuf[linelen-1] == '\r')
 329             fixedbuf[linelen-1] = 0;
 330           err = parm->data_cb (parm->data_cb_value, 0, fixedbuf);
 331         }
 332       else
 333         {
 334           if (linelen + 1 >= parm->helpbufsize)
 335             {
 336               xfree (parm->helpbuf);
 337               parm->helpbufsize = linelen + 1 + 1024;
 338               parm->helpbuf = xtrymalloc (parm->helpbufsize);
 339               if (!parm->helpbuf)
 340                 {
 341                   parm->lasterr = gpg_error_from_syserror ();
 342                   return parm->lasterr;
 343                 }
 344             }
 345           memcpy (parm->helpbuf, line, linelen);
 346           parm->helpbuf[linelen] = 0;
 347           if (linelen && parm->helpbuf[linelen-1] == '\r')
 348             parm->helpbuf[linelen-1] = 0;
 349           err = parm->data_cb (parm->data_cb_value, 0, parm->helpbuf);
 350         }
 351       if (err)
 352         parm->lasterr = err;
 353       else
 354         {
 355           clear_membuf (&parm->saveddata, linelen+1);
 356           goto again;  /* There might be another complete line.  */
 357         }
 358     }
 359
 360   return err;
 361 }
 362
 363
 364 /* Run the KS_SEARCH command using the search string SEARCHSTR.  All
 365    data lines are passed to the CB function.  That function is called
 366    with CB_VALUE as its first argument, a 0 as second argument, and
 367    the decoded data line as third argument.  The callback function may
 368    modify the data line and it is guaranteed that this data line is a
 369    complete line with a terminating 0 character but without the
 370    linefeed.  NULL is passed to the callback to indicate EOF.  */
 371 gpg_error_t
 372 gpg_dirmngr_ks_search (ctrl_t ctrl, const char *searchstr,
 373                        gpg_error_t (*cb)(void*, int, char *), void *cb_value)
 374 {
 375   gpg_error_t err;
 376   assuan_context_t ctx;
 377   struct ks_status_parm_s stparm;
 378   struct ks_search_parm_s parm;
 379   char line[ASSUAN_LINELENGTH];
 380
 381   err = open_context (ctrl, &ctx);
 382   if (err)
 383     return err;
 384
 385   {
 386     char *escsearchstr = percent_plus_escape (searchstr);
 387     if (!escsearchstr)
 388       {
 389         err = gpg_error_from_syserror ();
 390         close_context (ctrl, ctx);
 391         return err;
 392       }
 393     snprintf (line, sizeof line, "KS_SEARCH -- %s", escsearchstr);
 394     xfree (escsearchstr);
 395   }
 396
 397   memset (&stparm, 0, sizeof stparm);
 398   memset (&parm, 0, sizeof parm);
 399   init_membuf (&parm.saveddata, 1024);
 400   parm.data_cb = cb;
 401   parm.data_cb_value = cb_value;
 402   parm.stparm = &stparm;
 403
 404   err = assuan_transact (ctx, line, ks_search_data_cb, &parm,
 405                         NULL, NULL, ks_status_cb, &stparm);
 406   if (!err)
 407     err = cb (cb_value, 0, NULL);  /* Send EOF.  */
 408
 409   xfree (get_membuf (&parm.saveddata, NULL));
 410   xfree (parm.helpbuf);
 411   xfree (stparm.source);
 412
 413   close_context (ctrl, ctx);
 414   return err;
 415 }
 416
 417
 418 \f
 419 /* Data callback for the KS_GET and KS_FETCH commands. */
 420 static gpg_error_t
 421 ks_get_data_cb (void *opaque, const void *data, size_t datalen)
 422 {
 423   gpg_error_t err = 0;
 424   struct ks_get_parm_s *parm = opaque;
 425   size_t nwritten;
 426
 427   if (!data)
 428     return 0;  /* Ignore END commands.  */
 429
 430   if (es_write (parm->memfp, data, datalen, &nwritten))
 431     err = gpg_error_from_syserror ();
 432
 433   return err;
 434 }
 435
 436
 437 /* Run the KS_GET command using the patterns in the array PATTERN.  On
 438    success an estream object is returned to retrieve the keys.  On
 439    error an error code is returned and NULL stored at R_FP.
 440
 441    The pattern may only use search specification which a keyserver can
 442    use to retrieve keys.  Because we know the format of the pattern we
 443    don't need to escape the patterns before sending them to the
 444    server.
 445
 446    If R_SOURCE is not NULL the source of the data is stored as a
 447    malloced string there.  If a source is not known NULL is stored.
 448
 449    If there are too many patterns the function returns an error.  That
 450    could be fixed by issuing several search commands or by
 451    implementing a different interface.  However with long keyids we
 452    are able to ask for (1000-10-1)/(2+8+1) = 90 keys at once.  */
 453 gpg_error_t
 454 gpg_dirmngr_ks_get (ctrl_t ctrl, char **pattern,
 455                     estream_t *r_fp, char **r_source)
 456 {
 457   gpg_error_t err;
 458   assuan_context_t ctx;
 459   struct ks_status_parm_s stparm;
 460   struct ks_get_parm_s parm;
 461   char *line = NULL;
 462   size_t linelen;
 463   membuf_t mb;
 464   int idx;
 465
 466   memset (&stparm, 0, sizeof stparm);
 467   memset (&parm, 0, sizeof parm);
 468
 469   *r_fp = NULL;
 470   if (r_source)
 471     *r_source = NULL;
 472
 473   err = open_context (ctrl, &ctx);
 474   if (err)
 475     return err;
 476
 477   /* Lump all patterns into one string.  */
 478   init_membuf (&mb, 1024);
 479   put_membuf_str (&mb, "KS_GET --");
 480   for (idx=0; pattern[idx]; idx++)
 481     {
 482       put_membuf (&mb, " ", 1); /* Append Delimiter.  */
 483       put_membuf_str (&mb, pattern[idx]);
 484     }
 485   put_membuf (&mb, "", 1); /* Append Nul.  */
 486   line = get_membuf (&mb, &linelen);
 487   if (!line)
 488     {
 489       err = gpg_error_from_syserror ();
 490       goto leave;
 491     }
 492   if (linelen + 2 >= ASSUAN_LINELENGTH)
 493     {
 494       err = gpg_error (GPG_ERR_TOO_MANY);
 495       goto leave;
 496     }
 497
 498   parm.memfp = es_fopenmem (0, "rwb");
 499   if (!parm.memfp)
 500     {
 501       err = gpg_error_from_syserror ();
 502       goto leave;
 503     }
 504   err = assuan_transact (ctx, line, ks_get_data_cb, &parm,
 505                          NULL, NULL, ks_status_cb, &stparm);
 506   if (err)
 507     goto leave;
 508
 509   es_rewind (parm.memfp);
 510   *r_fp = parm.memfp;
 511   parm.memfp = NULL;
 512
 513   if (r_source)
 514     {
 515       *r_source = stparm.source;
 516       stparm.source = NULL;
 517     }
 518
 519  leave:
 520   es_fclose (parm.memfp);
 521   xfree (stparm.source);
 522   xfree (line);
 523   close_context (ctrl, ctx);
 524   return err;
 525 }
 526
 527
 528 /* Run the KS_FETCH and pass URL as argument.  On success an estream
 529    object is returned to retrieve the keys.  On error an error code is
 530    returned and NULL stored at R_FP.
 531
 532    The url is expected to point to a small set of keys; in many cases
 533    only to one key.  However, schemes like finger may return several
 534    keys.  Note that the configured keyservers are ignored by the
 535    KS_FETCH command.  */
 536 gpg_error_t
 537 gpg_dirmngr_ks_fetch (ctrl_t ctrl, const char *url, estream_t *r_fp)
 538 {
 539   gpg_error_t err;
 540   assuan_context_t ctx;
 541   struct ks_get_parm_s parm;
 542   char *line = NULL;
 543
 544   memset (&parm, 0, sizeof parm);
 545
 546   *r_fp = NULL;
 547
 548   err = open_context (ctrl, &ctx);
 549   if (err)
 550     return err;
 551
 552   line = strconcat ("KS_FETCH -- ", url, NULL);
 553   if (!line)
 554     {
 555       err = gpg_error_from_syserror ();
 556       goto leave;
 557     }
 558   if (strlen (line) + 2 >= ASSUAN_LINELENGTH)
 559     {
 560       err = gpg_error (GPG_ERR_TOO_LARGE);
 561       goto leave;
 562     }
 563
 564   parm.memfp = es_fopenmem (0, "rwb");
 565   if (!parm.memfp)
 566     {
 567       err = gpg_error_from_syserror ();
 568       goto leave;
 569     }
 570   err = assuan_transact (ctx, line, ks_get_data_cb, &parm,
 571                          NULL, NULL, NULL, NULL);
 572   if (err)
 573     goto leave;
 574
 575   es_rewind (parm.memfp);
 576   *r_fp = parm.memfp;
 577   parm.memfp = NULL;
 578
 579  leave:
 580   es_fclose (parm.memfp);
 581   xfree (line);
 582   close_context (ctrl, ctx);
 583   return err;
 584 }
 585
 586
 587 \f
 588 /* Handle the KS_PUT inquiries. */
 589 static gpg_error_t
 590 ks_put_inq_cb (void *opaque, const char *line)
 591 {
 592   struct ks_put_parm_s *parm = opaque;
 593   gpg_error_t err = 0;
 594
 595   if (has_leading_keyword (line, "KEYBLOCK"))
 596     {
 597       if (parm->data)
 598         err = assuan_send_data (parm->ctx, parm->data, parm->datalen);
 599     }
 600   else if (has_leading_keyword (line, "KEYBLOCK_INFO"))
 601     {
 602       kbnode_t node;
 603       estream_t fp;
 604
 605       /* Parse the keyblock and send info lines back to the server.  */
 606       fp = es_fopenmem (0, "rw,samethread");
 607       if (!fp)
 608         err = gpg_error_from_syserror ();
 609
 610       for (node = parm->keyblock; !err && node; node=node->next)
 611         {
 612           switch(node->pkt->pkttype)
 613             {
 614             case PKT_PUBLIC_KEY:
 615             case PKT_PUBLIC_SUBKEY:
 616               {
 617                 PKT_public_key *pk = node->pkt->pkt.public_key;
 618
 619                 keyid_from_pk (pk, NULL);
 620
 621                 es_fprintf (fp, "%s:%08lX%08lX:%u:%u:%u:%u:%s%s:\n",
 622                             node->pkt->pkttype==PKT_PUBLIC_KEY? "pub" : "sub",
 623                             (ulong)pk->keyid[0], (ulong)pk->keyid[1],
 624                             pk->pubkey_algo,
 625                             nbits_from_pk (pk),
 626                             pk->timestamp,
 627                             pk->expiredate,
 628                             pk->flags.revoked? "r":"",
 629                             pk->has_expired? "e":"");
 630               }
 631               break;
 632
 633             case PKT_USER_ID:
 634               {
 635                 PKT_user_id *uid = node->pkt->pkt.user_id;
 636                 int r;
 637
 638                 if (!uid->attrib_data)
 639                   {
 640                     es_fprintf (fp, "uid:");
 641
 642                     /* Quote ':', '%', and any 8-bit characters.  */
 643                     for (r=0; r < uid->len; r++)
 644                       {
 645                         if (uid->name[r] == ':'
 646                             || uid->name[r]== '%'
 647                             || (uid->name[r]&0x80))
 648                           es_fprintf (fp, "%%%02X", (byte)uid->name[r]);
 649                         else
 650                           es_putc (uid->name[r], fp);
 651                       }
 652
 653                     es_fprintf (fp, ":%u:%u:%s%s:\n",
 654                                 uid->created,uid->expiredate,
 655                                 uid->is_revoked? "r":"",
 656                                 uid->is_expired? "e":"");
 657                   }
 658               }
 659               break;
 660
 661               /* This bit is really for the benefit of people who
 662                  store their keys in LDAP servers.  It makes it easy
 663                  to do queries for things like "all keys signed by
 664                  Isabella".  */
 665             case PKT_SIGNATURE:
 666               {
 667                 PKT_signature *sig = node->pkt->pkt.signature;
 668
 669                 if (IS_UID_SIG (sig))
 670                   {
 671                     es_fprintf (fp, "sig:%08lX%08lX:%X:%u:%u:\n",
 672                                 (ulong)sig->keyid[0],(ulong)sig->keyid[1],
 673                                 sig->sig_class, sig->timestamp,
 674                                 sig->expiredate);
 675                   }
 676               }
 677               break;
 678
 679             default:
 680               continue;
 681             }
 682           /* Given that the last operation was an es_fprintf we should
 683              get the correct ERRNO if ferror indicates an error.  */
 684           if (es_ferror (fp))
 685             err = gpg_error_from_syserror ();
 686         }
 687
 688       /* Without an error and if we have an keyblock at all, send the
 689          data back.  */
 690       if (!err && parm->keyblock)
 691         {
 692           int rc;
 693           char buffer[512];
 694           size_t nread;
 695
 696           es_rewind (fp);
 697           while (!(rc=es_read (fp, buffer, sizeof buffer, &nread)) && nread)
 698             {
 699               err = assuan_send_data (parm->ctx, buffer, nread);
 700               if (err)
 701                 break;
 702             }
 703           if (!err && rc)
 704             err = gpg_error_from_syserror ();
 705         }
 706       es_fclose (fp);
 707     }
 708   else
 709     return gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
 710
 711   return err;
 712 }
 713
 714
 715 /* Send a key to the configured server.  {DATA,DATLEN} contains the
 716    key in OpenPGP binary transport format.  If KEYBLOCK is not NULL it
 717    has the internal representaion of that key; this is for example
 718    used to convey meta data to LDAP keyservers.  */
 719 gpg_error_t
 720 gpg_dirmngr_ks_put (ctrl_t ctrl, void *data, size_t datalen, kbnode_t keyblock)
 721 {
 722   gpg_error_t err;
 723   assuan_context_t ctx;
 724   struct ks_put_parm_s parm;
 725
 726   memset (&parm, 0, sizeof parm);
 727
 728   /* We are going to parse the keyblock, thus we better make sure the
 729      all information is readily available.  */
 730   if (keyblock)
 731     merge_keys_and_selfsig (keyblock);
 732
 733   err = open_context (ctrl, &ctx);
 734   if (err)
 735     return err;
 736
 737   parm.ctx = ctx;
 738   parm.keyblock = keyblock;
 739   parm.data = data;
 740   parm.datalen = datalen;
 741
 742   err = assuan_transact (ctx, "KS_PUT", NULL, NULL,
 743                          ks_put_inq_cb, &parm, NULL, NULL);
 744
 745   close_context (ctrl, ctx);
 746   return err;
 747 }