dirmngr/ldap-wrapper.c

   1 /* ldap-wrapper.c - LDAP access via a wrapper process
   2  * Copyright (C) 2004, 2005, 2007, 2008, 2018 g10 Code GmbH
   3  * Copyright (C) 2010 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 <https://www.gnu.org/licenses/>.
  19  */
  20
  21 /*
  22  * We can't use LDAP directly for these reasons:
  23  *
  24  * 1. On some systems the LDAP library uses (indirectly) pthreads and
  25  *    that is not compatible with GNU Pth.  Since 2.1 we use nPth
  26  *    instead of GNU Pth which does not have this problem anymore
  27  *    because it will use pthreads if the platform supports it.  Thus
  28  *    this was a historical reasons.
  29  *
  30  * 2. It is huge library in particular if TLS comes into play.  So
  31  *    problems with unfreed memory might turn up and we don't want
  32  *    this in a long running daemon.
  33  *
  34  * 3. There is no easy way for timeouts. In particular the timeout
  35  *    value does not work for DNS lookups (well, this is usual) and it
  36  *    seems not to work while loading a large attribute like a
  37  *    CRL. Having a separate process allows us to either tell the
  38  *    process to commit suicide or have our own housekepping function
  39  *    kill it after some time.  The latter also allows proper
  40  *    cancellation of a query at any point of time.
  41  *
  42  * 4. Given that we are going out to the network and usually get back
  43  *    a long response, the fork/exec overhead is acceptable.
  44  *
  45  * Note that under WindowsCE the number of processes is strongly
  46  * limited (32 processes including the kernel processes) and thus we
  47  * don't use the process approach but implement a different wrapper in
  48  * ldap-wrapper-ce.c.
  49  */
  50
  51
  52 #include <config.h>
  53
  54 #include <stdio.h>
  55 #include <stdlib.h>
  56 #include <string.h>
  57 #include <errno.h>
  58 #include <unistd.h>
  59 #include <fcntl.h>
  60 #include <time.h>
  61 #include <npth.h>
  62
  63 #include "dirmngr.h"
  64 #include "../common/exechelp.h"
  65 #include "misc.h"
  66 #include "ldap-wrapper.h"
  67
  68
  69 #ifdef HAVE_W32_SYSTEM
  70 #define setenv(a,b,c) SetEnvironmentVariable ((a),(b))
  71 #else
  72 #define pth_close(fd) close(fd)
  73 #endif
  74
  75 #ifndef USE_LDAPWRAPPER
  76 # error This module is not expected to be build.
  77 #endif
  78
  79 /* In case sysconf does not return a value we need to have a limit. */
  80 #ifdef _POSIX_OPEN_MAX
  81 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
  82 #else
  83 #define MAX_OPEN_FDS 20
  84 #endif
  85
  86 #define INACTIVITY_TIMEOUT (opt.ldaptimeout + 60*5)  /* seconds */
  87
  88 #define TIMERTICK_INTERVAL 2
  89
  90 /* To keep track of the LDAP wrapper state we use this structure.  */
  91 struct wrapper_context_s
  92 {
  93   struct wrapper_context_s *next;
  94
  95   pid_t pid;           /* The pid of the wrapper process. */
  96   int printable_pid;   /* Helper to print diagnostics after the process has
  97                         * been cleaned up. */
  98   estream_t fp;        /* Connected with stdout of the ldap wrapper.  */
  99   gpg_error_t fp_err;  /* Set to the gpg_error of the last read error
 100                         * if any.  */
 101   estream_t log_fp;    /* Connected with stderr of the ldap wrapper.  */
 102   ctrl_t ctrl;         /* Connection data. */
 103   int ready;           /* Internally used to mark to be removed contexts. */
 104   ksba_reader_t reader;/* The ksba reader object or NULL. */
 105   char *line;          /* Used to print the log lines (malloced). */
 106   size_t linesize;     /* Allocated size of LINE.  */
 107   size_t linelen;      /* Use size of LINE.  */
 108   time_t stamp;        /* The last time we noticed ativity.  */
 109   int reaper_idx;      /* Private to ldap_wrapper_thread.   */
 110 };
 111
 112
 113
 114 /* We keep a global list of spawned wrapper process.  A separate
 115  * thread makes use of this list to log error messages and to watch
 116  * out for finished processes.  Access to list is protected by a
 117  * mutex.  The condition variable is used to wakeup the reaper
 118  * thread.  */
 119 static struct wrapper_context_s *reaper_list;
 120 static npth_mutex_t reaper_list_mutex = NPTH_MUTEX_INITIALIZER;
 121 static npth_cond_t  reaper_run_cond  = NPTH_COND_INITIALIZER;
 122
 123 /* We need to know whether we are shutting down the process.  */
 124 static int shutting_down;
 125
 126
 127
 128 /* Close the estream fp and set it to NULL.  */
 129 #define SAFE_CLOSE(fp) \
 130   do { estream_t _fp = fp; es_fclose (_fp); fp = NULL; } while (0)
 131
 132
 133
 134 \f
 135
 136 static void
 137 lock_reaper_list (void)
 138 {
 139   if (npth_mutex_lock (&reaper_list_mutex))
 140     log_fatal ("%s: failed to acquire mutex: %s\n", __func__,
 141                gpg_strerror (gpg_error_from_syserror ()));
 142 }
 143
 144
 145 static void
 146 unlock_reaper_list (void)
 147 {
 148   if (npth_mutex_unlock (&reaper_list_mutex))
 149     log_fatal ("%s: failed to release mutex: %s\n", __func__,
 150                gpg_strerror (gpg_error_from_syserror ()));
 151 }
 152
 153
 154
 155 /* Read a fixed amount of data from READER into BUFFER.  */
 156 static gpg_error_t
 157 read_buffer (ksba_reader_t reader, unsigned char *buffer, size_t count)
 158 {
 159   gpg_error_t err;
 160   size_t nread;
 161
 162   while (count)
 163     {
 164       err = ksba_reader_read (reader, buffer, count, &nread);
 165       if (err)
 166         return err;
 167       buffer += nread;
 168       count -= nread;
 169     }
 170   return 0;
 171 }
 172
 173
 174 /* Release the wrapper context and kill a running wrapper process. */
 175 static void
 176 destroy_wrapper (struct wrapper_context_s *ctx)
 177 {
 178   if (ctx->pid != (pid_t)(-1))
 179     {
 180       gnupg_kill_process (ctx->pid);
 181       gnupg_release_process (ctx->pid);
 182     }
 183   ksba_reader_release (ctx->reader);
 184   SAFE_CLOSE (ctx->fp);
 185   SAFE_CLOSE (ctx->log_fp);
 186   xfree (ctx->line);
 187   xfree (ctx);
 188 }
 189
 190
 191 /* Print the content of LINE to thye log stream but make sure to only
 192    print complete lines.  Using NULL for LINE will flush any pending
 193    output.  LINE may be modified by this function. */
 194 static void
 195 print_log_line (struct wrapper_context_s *ctx, char *line)
 196 {
 197   char *s;
 198   size_t n;
 199
 200   if (!line)
 201     {
 202       if (ctx->line && ctx->linelen)
 203         {
 204
 205           log_info ("%s\n", ctx->line);
 206           ctx->linelen = 0;
 207         }
 208       return;
 209     }
 210
 211   while ((s = strchr (line, '\n')))
 212     {
 213       *s = 0;
 214       if (ctx->line && ctx->linelen)
 215         {
 216           log_info ("%s", ctx->line);
 217           ctx->linelen = 0;
 218           log_printf ("%s\n", line);
 219         }
 220       else
 221         log_info ("%s\n", line);
 222       line = s + 1;
 223     }
 224   n = strlen (line);
 225   if (n)
 226     {
 227       if (ctx->linelen + n + 1 >= ctx->linesize)
 228         {
 229           char *tmp;
 230           size_t newsize;
 231
 232           newsize = ctx->linesize + ((n + 255) & ~255) + 1;
 233           tmp = (ctx->line ? xtryrealloc (ctx->line, newsize)
 234                            : xtrymalloc (newsize));
 235           if (!tmp)
 236             {
 237               log_error (_("error printing log line: %s\n"), strerror (errno));
 238               return;
 239             }
 240           ctx->line = tmp;
 241           ctx->linesize = newsize;
 242         }
 243       memcpy (ctx->line + ctx->linelen, line, n);
 244       ctx->linelen += n;
 245       ctx->line[ctx->linelen] = 0;
 246     }
 247 }
 248
 249
 250 /* Read data from the log stream.  Returns true if the log stream
 251  * indicated EOF or error.  */
 252 static int
 253 read_log_data (struct wrapper_context_s *ctx)
 254 {
 255   int rc;
 256   size_t n;
 257   char line[256];
 258
 259   rc = es_read (ctx->log_fp, line, sizeof line - 1, &n);
 260   if (rc || !n)  /* Error or EOF.  */
 261     {
 262       if (rc)
 263         {
 264           gpg_error_t err = gpg_error_from_syserror ();
 265           if (gpg_err_code (err) == GPG_ERR_EAGAIN)
 266             return 0;
 267           log_error (_("error reading log from ldap wrapper %d: %s\n"),
 268                      (int)ctx->pid, gpg_strerror (err));
 269         }
 270       print_log_line (ctx, NULL);  /* Flush.  */
 271       SAFE_CLOSE (ctx->log_fp);
 272       return 1;
 273     }
 274
 275   line[n] = 0;
 276   print_log_line (ctx, line);
 277   if (ctx->stamp != (time_t)(-1))
 278     ctx->stamp = time (NULL);
 279   return 0;
 280 }
 281
 282
 283 /* This function is run by a separate thread to maintain the list of
 284    wrappers and to log error messages from these wrappers.  */
 285 void *
 286 ldap_reaper_thread (void *dummy)
 287 {
 288   gpg_error_t err;
 289   struct wrapper_context_s *ctx;
 290   struct wrapper_context_s *ctx_prev;
 291   struct timespec abstime;
 292   struct timespec curtime;
 293   struct timespec timeout;
 294   int millisecs;
 295   gpgrt_poll_t *fparray = NULL;
 296   int fparraysize = 0;
 297   int count, i;
 298   int ret;
 299   time_t exptime;
 300
 301   (void)dummy;
 302
 303   npth_clock_gettime (&abstime);
 304   abstime.tv_sec += TIMERTICK_INTERVAL;
 305
 306   for (;;)
 307     {
 308       int any_action = 0;
 309
 310       /* Wait until we are needed and then setup the FPARRAY.  */
 311       /* Note: There is one unlock inside the block!  */
 312       lock_reaper_list ();
 313       {
 314         while (!reaper_list && !shutting_down)
 315           {
 316             if (npth_cond_wait (&reaper_run_cond, &reaper_list_mutex))
 317               log_error ("ldap-reaper: waiting on condition failed: %s\n",
 318                          gpg_strerror (gpg_error_from_syserror ()));
 319           }
 320
 321         for (count = 0, ctx = reaper_list; ctx; ctx = ctx->next)
 322           if (ctx->log_fp)
 323             count++;
 324         if (count > fparraysize || !fparray)
 325           {
 326             /* Need to realloc the array.  We simply discard it and
 327              * replace it by a new one.  */
 328             xfree (fparray);
 329             fparray = xtrycalloc (count? count : 1, sizeof *fparray);
 330             if (!fparray)
 331               {
 332                 err = gpg_error_from_syserror ();
 333                 log_error ("ldap-reaper can't allocate poll array: %s"
 334                            " - waiting 1s\n", gpg_strerror (err));
 335                 /* Note: Here we unlock and continue! */
 336                 unlock_reaper_list ();
 337                 npth_sleep (1);
 338                 continue;
 339             }
 340             fparraysize = count;
 341           }
 342         for (count = 0, ctx = reaper_list; ctx; ctx = ctx->next)
 343           {
 344             if (ctx->log_fp)
 345               {
 346                 log_assert (count < fparraysize);
 347                 fparray[count].stream = ctx->log_fp;
 348                 fparray[count].want_read = 1;
 349                 fparray[count].ignore = 0;
 350                 ctx->reaper_idx = count;
 351                 count++;
 352               }
 353             else
 354               {
 355                 ctx->reaper_idx = -1;
 356                 fparray[count].ignore = 1;
 357               }
 358           }
 359         for (i=count; i < fparraysize; i++)
 360           fparray[i].ignore = 1;
 361       }
 362       unlock_reaper_list (); /* Note the one unlock inside the block.  */
 363
 364       /* Compute the next timeout.  */
 365       npth_clock_gettime (&curtime);
 366       if (!(npth_timercmp (&curtime, &abstime, <)))
 367         {
 368           /* Inactivity is checked below.  Nothing else to do.  */
 369           npth_clock_gettime (&abstime);
 370           abstime.tv_sec += TIMERTICK_INTERVAL;
 371         }
 372       npth_timersub (&abstime, &curtime, &timeout);
 373       millisecs = timeout.tv_sec * 1000;
 374       millisecs += timeout.tv_nsec / 1000000;
 375       if (millisecs < 0)
 376         millisecs = 1;
 377
 378       if (DBG_EXTPROG)
 379         {
 380           log_debug ("ldap-reaper: next run (count=%d size=%d, timeout=%d)\n",
 381                      count, fparraysize, millisecs);
 382           for (count=0; count < fparraysize; count++)
 383             if (!fparray[count].ignore)
 384               log_debug ("ldap-reaper: fp[%d] stream=%p want=%d\n",
 385                          count, fparray[count].stream,fparray[count].want_read);
 386         }
 387
 388       ret = es_poll (fparray, fparraysize, millisecs);
 389       if (ret < 0)
 390         {
 391           err = gpg_error_from_syserror ();
 392           log_error ("ldap-reaper failed to poll: %s"
 393                      " - waiting 1s\n", gpg_strerror (err));
 394           /* In case the reason for the error is a too large array, we
 395            * release it so that it will be allocated smaller in the
 396            * next round.  */
 397           xfree (fparray);
 398           fparray = NULL;
 399           fparraysize = 0;
 400           npth_sleep (1);
 401           continue;
 402         }
 403
 404       if (DBG_EXTPROG)
 405         {
 406           for (count=0; count < fparraysize; count++)
 407             if (!fparray[count].ignore)
 408               log_debug ("ldap-reaper: fp[%d] stream=%p r=%d %c%c%c%c%c%c%c\n",
 409                          count, fparray[count].stream, ret,
 410                          fparray[count].got_read? 'r':'-',
 411                          fparray[count].got_write?'w':'-',
 412                          fparray[count].got_oob?  'o':'-',
 413                          fparray[count].got_rdhup?'H':'-',
 414                          fparray[count].got_err?  'e':'-',
 415                          fparray[count].got_hup?  'h':'-',
 416                          fparray[count].got_nval? 'n':'-');
 417         }
 418
 419       /* All timestamps before exptime should be considered expired.  */
 420       exptime = time (NULL);
 421       if (exptime > INACTIVITY_TIMEOUT)
 422         exptime -= INACTIVITY_TIMEOUT;
 423
 424       lock_reaper_list ();
 425       {
 426         for (ctx = reaper_list; ctx; ctx = ctx->next)
 427           {
 428             /* Check whether there is any logging to be done.  We need
 429              * to check FPARRAYSIZE because it can be 0 in case
 430              * es_poll returned a timeout.  */
 431             if (fparraysize && ctx->log_fp && ctx->reaper_idx >= 0)
 432               {
 433                 log_assert (ctx->reaper_idx < fparraysize);
 434                 if (fparray[ctx->reaper_idx].got_read)
 435                   {
 436                     if (read_log_data (ctx))
 437                       {
 438                         SAFE_CLOSE (ctx->log_fp);
 439                         any_action = 1;
 440                       }
 441                   }
 442               }
 443
 444             /* Check whether the process is still running.  */
 445             if (ctx->pid != (pid_t)(-1))
 446               {
 447                 int status;
 448
 449                 err = gnupg_wait_process ("[dirmngr_ldap]", ctx->pid, 0,
 450                                           &status);
 451                 if (!err)
 452                   {
 453                     if (DBG_EXTPROG)
 454                       log_info (_("ldap wrapper %d ready"), (int)ctx->pid);
 455                     ctx->ready = 1;
 456                     gnupg_release_process (ctx->pid);
 457                     ctx->pid = (pid_t)(-1);
 458                     any_action = 1;
 459                   }
 460                 else if (gpg_err_code (err) == GPG_ERR_GENERAL)
 461                   {
 462                     if (status == 10)
 463                       log_info (_("ldap wrapper %d ready: timeout\n"),
 464                                 (int)ctx->pid);
 465                     else
 466                       log_info (_("ldap wrapper %d ready: exitcode=%d\n"),
 467                                 (int)ctx->pid, status);
 468                     ctx->ready = 1;
 469                     gnupg_release_process (ctx->pid);
 470                     ctx->pid = (pid_t)(-1);
 471                     any_action = 1;
 472                   }
 473                 else if (gpg_err_code (err) != GPG_ERR_TIMEOUT)
 474                   {
 475                     log_error (_("waiting for ldap wrapper %d failed: %s\n"),
 476                                (int)ctx->pid, gpg_strerror (err));
 477                     any_action = 1;
 478                   }
 479               }
 480
 481             /* Check whether we should terminate the process. */
 482             if (ctx->pid != (pid_t)(-1)
 483                 && ctx->stamp != (time_t)(-1) && ctx->stamp < exptime)
 484               {
 485                 gnupg_kill_process (ctx->pid);
 486                 ctx->stamp = (time_t)(-1);
 487                 log_info (_("ldap wrapper %d stalled - killing\n"),
 488                           (int)ctx->pid);
 489                 /* We need to close the log stream because the cleanup
 490                  * loop waits for it.  */
 491                 SAFE_CLOSE (ctx->log_fp);
 492                 any_action = 1;
 493               }
 494           }
 495
 496         /* If something has been printed to the log file or we got an
 497          * EOF from a wrapper, we now print the list of active
 498          * wrappers.  */
 499         if (any_action && DBG_EXTPROG)
 500           {
 501             log_debug ("ldap worker stati:\n");
 502             for (ctx = reaper_list; ctx; ctx = ctx->next)
 503               log_debug ("  c=%p pid=%d/%d rdr=%p logfp=%p"
 504                          " ctrl=%p/%d la=%lu rdy=%d\n",
 505                          ctx,
 506                          (int)ctx->pid, (int)ctx->printable_pid,
 507                          ctx->reader, ctx->log_fp,
 508                          ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0,
 509                          (unsigned long)ctx->stamp, ctx->ready);
 510           }
 511
 512         /* An extra loop to check whether ready marked wrappers may be
 513          * removed.  We may only do so if the ksba reader object is
 514          * not anymore in use or we are in shutdown state.  */
 515       again:
 516         for (ctx_prev=NULL, ctx=reaper_list; ctx; ctx_prev=ctx, ctx=ctx->next)
 517           {
 518             if (ctx->ready
 519                 && ((!ctx->log_fp && !ctx->reader) || shutting_down))
 520               {
 521                 if (ctx_prev)
 522                   ctx_prev->next = ctx->next;
 523                 else
 524                   reaper_list = ctx->next;
 525                 destroy_wrapper (ctx);
 526                 goto again;
 527               }
 528           }
 529       }
 530       unlock_reaper_list ();
 531     }
 532
 533   /*NOTREACHED*/
 534   return NULL; /* Make the compiler happy.  */
 535 }
 536
 537
 538
 539 /* Start the reaper thread for the ldap wrapper.  */
 540 void
 541 ldap_reaper_launch_thread (void)
 542 {
 543   static int done;
 544   npth_attr_t tattr;
 545   npth_t thread;
 546   int err;
 547
 548   if (done)
 549     return;
 550   done = 1;
 551
 552 #ifdef HAVE_W32_SYSTEM
 553   /* Static init does not yet work in W32 nPth.  */
 554   if (npth_cond_init (&reaper_run_cond, NULL))
 555     log_fatal ("%s: failed to init condition variabale: %s\n",
 556                __func__, gpg_strerror (gpg_error_from_syserror ()));
 557 #endif
 558
 559   npth_attr_init (&tattr);
 560   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
 561
 562   if (npth_create (&thread, &tattr, ldap_reaper_thread, NULL))
 563     {
 564       err = gpg_error_from_syserror ();
 565       log_error ("error spawning ldap reaper reaper thread: %s\n",
 566                  gpg_strerror (err) );
 567       dirmngr_exit (1);
 568     }
 569   npth_setname_np (thread, "ldap-reaper");
 570   npth_attr_destroy (&tattr);
 571 }
 572
 573
 574
 575 /* Wait until all ldap wrappers have terminated.  We assume that the
 576    kill has already been sent to all of them.  */
 577 void
 578 ldap_wrapper_wait_connections ()
 579 {
 580   lock_reaper_list ();
 581   {
 582     shutting_down = 1;
 583     if (npth_cond_signal (&reaper_run_cond))
 584       log_error ("%s: Ooops: signaling condition failed: %s\n",
 585                  __func__, gpg_strerror (gpg_error_from_syserror ()));
 586   }
 587   unlock_reaper_list ();
 588   while (reaper_list)
 589     npth_usleep (200);
 590 }
 591
 592
 593 /* This function is to be used to release a context associated with the
 594    given reader object. */
 595 void
 596 ldap_wrapper_release_context (ksba_reader_t reader)
 597 {
 598   struct wrapper_context_s *ctx;
 599
 600   if (!reader )
 601     return;
 602
 603   lock_reaper_list ();
 604   {
 605     for (ctx=reaper_list; ctx; ctx=ctx->next)
 606       if (ctx->reader == reader)
 607         {
 608           if (DBG_EXTPROG)
 609             log_debug ("releasing ldap worker c=%p pid=%d/%d rdr=%p"
 610                        " ctrl=%p/%d\n", ctx,
 611                        (int)ctx->pid, (int)ctx->printable_pid,
 612                        ctx->reader,
 613                        ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0);
 614
 615           ctx->reader = NULL;
 616           SAFE_CLOSE (ctx->fp);
 617           if (ctx->ctrl)
 618             {
 619               ctx->ctrl->refcount--;
 620               ctx->ctrl = NULL;
 621             }
 622           if (ctx->fp_err)
 623             log_info ("%s: reading from ldap wrapper %d failed: %s\n",
 624                       __func__, ctx->printable_pid, gpg_strerror (ctx->fp_err));
 625           break;
 626         }
 627   }
 628   unlock_reaper_list ();
 629 }
 630
 631
 632 /* Cleanup all resources held by the connection associated with
 633    CTRL.  This is used after a cancel to kill running wrappers.  */
 634 void
 635 ldap_wrapper_connection_cleanup (ctrl_t ctrl)
 636 {
 637   struct wrapper_context_s *ctx;
 638
 639   lock_reaper_list ();
 640   {
 641     for (ctx=reaper_list; ctx; ctx=ctx->next)
 642       if (ctx->ctrl && ctx->ctrl == ctrl)
 643         {
 644           ctx->ctrl->refcount--;
 645           ctx->ctrl = NULL;
 646           if (ctx->pid != (pid_t)(-1))
 647             gnupg_kill_process (ctx->pid);
 648           if (ctx->fp_err)
 649             log_info ("%s: reading from ldap wrapper %d failed: %s\n",
 650                       __func__, ctx->printable_pid, gpg_strerror (ctx->fp_err));
 651         }
 652   }
 653   unlock_reaper_list ();
 654 }
 655
 656
 657 /* This is the callback used by the ldap wrapper to feed the ksba
 658  * reader with the wrapper's stdout.  See the description of
 659  * ksba_reader_set_cb for details.  */
 660 static int
 661 reader_callback (void *cb_value, char *buffer, size_t count,  size_t *nread)
 662 {
 663   struct wrapper_context_s *ctx = cb_value;
 664   size_t nleft = count;
 665   struct timespec abstime;
 666   struct timespec curtime;
 667   struct timespec timeout;
 668   int millisecs;
 669   gpgrt_poll_t fparray[1];
 670   int ret;
 671   gpg_error_t err;
 672
 673
 674   /* FIXME: We might want to add some internal buffering because the
 675      ksba code does not do any buffering for itself (because a ksba
 676      reader may be detached from another stream to read other data and
 677      then it would be cumbersome to get back already buffered stuff).  */
 678
 679   if (!buffer && !count && !nread)
 680     return -1; /* Rewind is not supported. */
 681
 682   /* If we ever encountered a read error, don't continue (we don't want to
 683      possibly overwrite the last error cause).  Bail out also if the
 684      file descriptor has been closed. */
 685   if (ctx->fp_err || !ctx->fp)
 686     {
 687       *nread = 0;
 688       return -1;
 689     }
 690
 691   memset (fparray, 0, sizeof fparray);
 692   fparray[0].stream = ctx->fp;
 693   fparray[0].want_read = 1;
 694
 695   npth_clock_gettime (&abstime);
 696   abstime.tv_sec += TIMERTICK_INTERVAL;
 697
 698   while (nleft > 0)
 699     {
 700       npth_clock_gettime (&curtime);
 701       if (!(npth_timercmp (&curtime, &abstime, <)))
 702         {
 703           err = dirmngr_tick (ctx->ctrl);
 704           if (err)
 705             {
 706               ctx->fp_err = err;
 707               SAFE_CLOSE (ctx->fp);
 708               return -1;
 709             }
 710           npth_clock_gettime (&abstime);
 711           abstime.tv_sec += TIMERTICK_INTERVAL;
 712         }
 713       npth_timersub (&abstime, &curtime, &timeout);
 714       millisecs = timeout.tv_sec * 1000;
 715       millisecs += timeout.tv_nsec / 1000000;
 716       if (millisecs < 0)
 717         millisecs = 1;
 718
 719       if (DBG_EXTPROG)
 720         {
 721           log_debug ("%s: fp[0] stream=%p want=%d\n",
 722                      __func__, fparray[0].stream,fparray[0].want_read);
 723         }
 724
 725       ret = es_poll (fparray, DIM (fparray), millisecs);
 726       if (ret < 0)
 727         {
 728           ctx->fp_err = gpg_error_from_syserror ();
 729           log_error ("error polling stdout of ldap wrapper %d: %s\n",
 730                      ctx->printable_pid, gpg_strerror (ctx->fp_err));
 731           SAFE_CLOSE (ctx->fp);
 732           return -1;
 733         }
 734       if (DBG_EXTPROG)
 735         {
 736           log_debug ("%s: fp[0] stream=%p r=%d %c%c%c%c%c%c%c\n",
 737                      __func__, fparray[0].stream, ret,
 738                      fparray[0].got_read? 'r':'-',
 739                      fparray[0].got_write?'w':'-',
 740                      fparray[0].got_oob?  'o':'-',
 741                      fparray[0].got_rdhup?'H':'-',
 742                      fparray[0].got_err?  'e':'-',
 743                      fparray[0].got_hup?  'h':'-',
 744                      fparray[0].got_nval? 'n':'-');
 745         }
 746       if (!ret)
 747         {
 748           /* Timeout.  Will be handled when calculating the next timeout.  */
 749           continue;
 750         }
 751
 752       if (fparray[0].got_read)
 753         {
 754           size_t n;
 755
 756           if (es_read (ctx->fp, buffer, nleft, &n))
 757             {
 758               ctx->fp_err = gpg_error_from_syserror ();
 759               if (gpg_err_code (ctx->fp_err) == GPG_ERR_EAGAIN)
 760                 ctx->fp_err = 0;
 761               else
 762                 {
 763                   log_error ("%s: error reading: %s (%d)\n",
 764                              __func__, gpg_strerror (ctx->fp_err), ctx->fp_err);
 765                   SAFE_CLOSE (ctx->fp);
 766                   return -1;
 767                 }
 768             }
 769           else if (!n) /* EOF */
 770             {
 771               if (nleft == count)
 772                 return -1; /* EOF. */
 773               break;
 774             }
 775           nleft -= n;
 776           buffer += n;
 777           if (n > 0 && ctx->stamp != (time_t)(-1))
 778             ctx->stamp = time (NULL);
 779         }
 780     }
 781   *nread = count - nleft;
 782
 783   return 0;
 784 }
 785
 786
 787 /* Fork and exec the LDAP wrapper and return a new libksba reader
 788    object at READER.  ARGV is a NULL terminated list of arguments for
 789    the wrapper.  The function returns 0 on success or an error code.
 790
 791    Special hack to avoid passing a password through the command line
 792    which is globally visible: If the first element of ARGV is "--pass"
 793    it will be removed and instead the environment variable
 794    DIRMNGR_LDAP_PASS will be set to the next value of ARGV.  On modern
 795    OSes the environment is not visible to other users.  For those old
 796    systems where it can't be avoided, we don't want to go into the
 797    hassle of passing the password via stdin; it's just too complicated
 798    and an LDAP password used for public directory lookups should not
 799    be that confidential.  */
 800 gpg_error_t
 801 ldap_wrapper (ctrl_t ctrl, ksba_reader_t *reader, const char *argv[])
 802 {
 803   gpg_error_t err;
 804   pid_t pid;
 805   struct wrapper_context_s *ctx;
 806   int i;
 807   int j;
 808   const char **arg_list;
 809   const char *pgmname;
 810   estream_t outfp, errfp;
 811
 812   /* It would be too simple to connect stderr just to our logging
 813      stream.  The problem is that if we are running multi-threaded
 814      everything gets intermixed.  Clearly we don't want this.  So the
 815      only viable solutions are either to have another thread
 816      responsible for logging the messages or to add an option to the
 817      wrapper module to do the logging on its own.  Given that we anyway
 818      need a way to reap the child process and this is best done using a
 819      general reaping thread, that thread can do the logging too. */
 820   ldap_reaper_launch_thread ();
 821
 822   *reader = NULL;
 823
 824   /* Files: We need to prepare stdin and stdout.  We get stderr from
 825      the function.  */
 826   if (!opt.ldap_wrapper_program || !*opt.ldap_wrapper_program)
 827     pgmname = gnupg_module_name (GNUPG_MODULE_NAME_DIRMNGR_LDAP);
 828   else
 829     pgmname = opt.ldap_wrapper_program;
 830
 831   /* Create command line argument array.  */
 832   for (i = 0; argv[i]; i++)
 833     ;
 834   arg_list = xtrycalloc (i + 2, sizeof *arg_list);
 835   if (!arg_list)
 836     {
 837       err = gpg_error_from_syserror ();
 838       log_error (_("error allocating memory: %s\n"), strerror (errno));
 839       return err;
 840     }
 841   for (i = j = 0; argv[i]; i++, j++)
 842     if (!i && argv[i + 1] && !strcmp (*argv, "--pass"))
 843       {
 844         arg_list[j] = "--env-pass";
 845         setenv ("DIRMNGR_LDAP_PASS", argv[1], 1);
 846         i++;
 847       }
 848     else
 849       arg_list[j] = (char*) argv[i];
 850
 851   ctx = xtrycalloc (1, sizeof *ctx);
 852   if (!ctx)
 853     {
 854       err = gpg_error_from_syserror ();
 855       log_error (_("error allocating memory: %s\n"), strerror (errno));
 856       xfree (arg_list);
 857       return err;
 858     }
 859
 860   err = gnupg_spawn_process (pgmname, arg_list,
 861                              NULL, NULL, GNUPG_SPAWN_NONBLOCK,
 862                              NULL, &outfp, &errfp, &pid);
 863   xfree (arg_list);
 864   if (err)
 865     {
 866       xfree (ctx);
 867       log_error ("error running '%s': %s\n", pgmname, gpg_strerror (err));
 868       return err;
 869     }
 870
 871   ctx->pid = pid;
 872   ctx->printable_pid = (int) pid;
 873   ctx->fp = outfp;
 874   ctx->log_fp = errfp;
 875   ctx->ctrl = ctrl;
 876   ctrl->refcount++;
 877   ctx->stamp = time (NULL);
 878
 879   err = ksba_reader_new (reader);
 880   if (!err)
 881     err = ksba_reader_set_cb (*reader, reader_callback, ctx);
 882   if (err)
 883     {
 884       log_error (_("error initializing reader object: %s\n"),
 885                  gpg_strerror (err));
 886       destroy_wrapper (ctx);
 887       ksba_reader_release (*reader);
 888       *reader = NULL;
 889       return err;
 890     }
 891
 892   /* Hook the context into our list of running wrappers.  */
 893   lock_reaper_list ();
 894   {
 895     ctx->reader = *reader;
 896     ctx->next = reaper_list;
 897     reaper_list = ctx;
 898     if (npth_cond_signal (&reaper_run_cond))
 899       log_error ("ldap-wrapper: Ooops: signaling condition failed: %s (%d)\n",
 900                  gpg_strerror (gpg_error_from_syserror ()), errno);
 901   }
 902   unlock_reaper_list ();
 903
 904   if (DBG_EXTPROG)
 905     log_debug ("ldap wrapper %d started (%p, %s)\n",
 906                (int)ctx->pid, ctx->reader, pgmname);
 907
 908   /* Need to wait for the first byte so we are able to detect an empty
 909      output and not let the consumer see an EOF without further error
 910      indications.  The CRL loading logic assumes that after return
 911      from this function, a failed search (e.g. host not found ) is
 912      indicated right away. */
 913   {
 914     unsigned char c;
 915
 916     err = read_buffer (*reader, &c, 1);
 917     if (err)
 918       {
 919         ldap_wrapper_release_context (*reader);
 920         ksba_reader_release (*reader);
 921         *reader = NULL;
 922         if (gpg_err_code (err) == GPG_ERR_EOF)
 923           return gpg_error (GPG_ERR_NO_DATA);
 924         else
 925           return err;
 926       }
 927     ksba_reader_unread (*reader, &c, 1);
 928   }
 929
 930   return 0;
 931 }