dirmngr: Use the LDAP wrapper process also for Windows.
[gnupg.git] / 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 thread
115    makes use of this list to log error messages and to watch out for
116    finished processes. */
117 static struct wrapper_context_s *wrapper_list;
118
119 /* We need to know whether we are shutting down the process.  */
120 static int shutting_down;
121
122 /* Close the estream fp and set it to NULL.  */
123 #define SAFE_CLOSE(fp) \
124   do { estream_t _fp = fp; es_fclose (_fp); fp = NULL; } while (0)
125
126
127
128 \f
129 /* Read a fixed amount of data from READER into BUFFER.  */
130 static gpg_error_t
131 read_buffer (ksba_reader_t reader, unsigned char *buffer, size_t count)
132 {
133   gpg_error_t err;
134   size_t nread;
135
136   while (count)
137     {
138       err = ksba_reader_read (reader, buffer, count, &nread);
139       if (err)
140         return err;
141       buffer += nread;
142       count -= nread;
143     }
144   return 0;
145 }
146
147
148 /* Release the wrapper context and kill a running wrapper process. */
149 static void
150 destroy_wrapper (struct wrapper_context_s *ctx)
151 {
152   if (ctx->pid != (pid_t)(-1))
153     {
154       gnupg_kill_process (ctx->pid);
155       gnupg_release_process (ctx->pid);
156     }
157   ksba_reader_release (ctx->reader);
158   SAFE_CLOSE (ctx->fp);
159   SAFE_CLOSE (ctx->log_fp);
160   xfree (ctx->line);
161   xfree (ctx);
162 }
163
164
165 /* Print the content of LINE to thye log stream but make sure to only
166    print complete lines.  Using NULL for LINE will flush any pending
167    output.  LINE may be modified by this function. */
168 static void
169 print_log_line (struct wrapper_context_s *ctx, char *line)
170 {
171   char *s;
172   size_t n;
173
174   if (!line)
175     {
176       if (ctx->line && ctx->linelen)
177         {
178
179           log_info ("%s\n", ctx->line);
180           ctx->linelen = 0;
181         }
182       return;
183     }
184
185   while ((s = strchr (line, '\n')))
186     {
187       *s = 0;
188       if (ctx->line && ctx->linelen)
189         {
190           log_info ("%s", ctx->line);
191           ctx->linelen = 0;
192           log_printf ("%s\n", line);
193         }
194       else
195         log_info ("%s\n", line);
196       line = s + 1;
197     }
198   n = strlen (line);
199   if (n)
200     {
201       if (ctx->linelen + n + 1 >= ctx->linesize)
202         {
203           char *tmp;
204           size_t newsize;
205
206           newsize = ctx->linesize + ((n + 255) & ~255) + 1;
207           tmp = (ctx->line ? xtryrealloc (ctx->line, newsize)
208                            : xtrymalloc (newsize));
209           if (!tmp)
210             {
211               log_error (_("error printing log line: %s\n"), strerror (errno));
212               return;
213             }
214           ctx->line = tmp;
215           ctx->linesize = newsize;
216         }
217       memcpy (ctx->line + ctx->linelen, line, n);
218       ctx->linelen += n;
219       ctx->line[ctx->linelen] = 0;
220     }
221 }
222
223
224 /* Read data from the log stream.  Returns true if the log stream
225  * indicated EOF or error.  */
226 static int
227 read_log_data (struct wrapper_context_s *ctx)
228 {
229   int rc;
230   size_t n;
231   char line[256];
232
233   rc = es_read (ctx->log_fp, line, sizeof line - 1, &n);
234   if (rc || !n)  /* Error or EOF.  */
235     {
236       if (rc)
237         log_error (_("error reading log from ldap wrapper %d: %s\n"),
238                    (int)ctx->pid, strerror (errno));
239       print_log_line (ctx, NULL);  /* Flush.  */
240       SAFE_CLOSE (ctx->log_fp);
241       return 1;
242     }
243
244   line[n] = 0;
245   print_log_line (ctx, line);
246   if (ctx->stamp != (time_t)(-1))
247     ctx->stamp = time (NULL);
248   return 0;
249 }
250
251
252 /* This function is run by a separate thread to maintain the list of
253    wrappers and to log error messages from these wrappers.  */
254 void *
255 ldap_wrapper_thread (void *dummy)
256 {
257   gpg_error_t err;
258   struct wrapper_context_s *ctx;
259   struct wrapper_context_s *ctx_prev;
260   struct timespec abstime;
261   struct timespec curtime;
262   struct timespec timeout;
263   int millisecs;
264   gpgrt_poll_t *fparray = NULL;
265   int fparraysize = 0;
266   int count;
267   int ret;
268   time_t exptime;
269
270   (void)dummy;
271
272   npth_clock_gettime (&abstime);
273   abstime.tv_sec += TIMERTICK_INTERVAL;
274
275   /* FIXME: When we are idle (i.e. !COUNT) we should not use the
276    * TIMERTICK_INTERVAL but wait on a mutex to avoid unnecessary
277    * wakeups.  */
278
279  restart:
280   for (;;)
281     {
282       int any_action = 0;
283
284       npth_clock_gettime (&curtime);
285       if (!(npth_timercmp (&curtime, &abstime, <)))
286         {
287           /* Inactivity is checked below.  Nothing else to do.  */
288           npth_clock_gettime (&abstime);
289           abstime.tv_sec += TIMERTICK_INTERVAL;
290         }
291       npth_timersub (&abstime, &curtime, &timeout);
292       millisecs = timeout.tv_sec * 1000;
293       millisecs += timeout.tv_nsec / 1000000;
294       if (millisecs < 0)
295         millisecs = 1;
296
297       /* Setup FPARRAY.  */
298       for (count = 0, ctx = wrapper_list; ctx; ctx = ctx->next)
299         if (ctx->log_fp)
300           count++;
301       if (DBG_EXTPROG)
302         log_debug ("ldap-reaper: next run (count=%d size=%d, timeout=%d)\n",
303                    count, fparraysize, millisecs);
304       if (count > fparraysize || !fparray)
305         {
306           /* Need to realloc the array.  We simply discard it and
307            * replace it by a new one.  */
308           xfree (fparray);
309           fparray = xtrycalloc (count? count : 1, sizeof *fparray);
310           if (!fparray)
311             {
312               err = gpg_error_from_syserror ();
313               log_error ("ldap-reaper can't allocate poll array: %s"
314                          " - waiting 1s\n", gpg_strerror (err));
315               npth_sleep (1);
316               continue;
317             }
318           fparraysize = count;
319         }
320       for (count = 0, ctx = wrapper_list; ctx; ctx = ctx->next)
321         {
322           if (ctx->log_fp)
323             {
324               if (count > fparraysize)
325                 {
326                   /* Another thread added more items to WRAPPER_LIST.
327                    * Note that the calloc above is a system call and
328                    * thus may caused a context switch. */
329                   goto restart;
330                 }
331               fparray[count].stream = ctx->log_fp;
332               fparray[count].want_read = 1;
333               fparray[count].ignore = 0;
334               ctx->reaper_idx = count;
335               count++;
336             }
337           else
338             ctx->reaper_idx = -1;
339         }
340       for (; count < fparraysize; count++)
341         fparray[count].ignore = 1;
342
343       if (DBG_EXTPROG)
344         {
345           for (count=0; count < fparraysize; count++)
346             if (!fparray[count].ignore)
347               log_debug ("ldap-reaper: fp[%d] stream=%p want=%d\n",
348                          count, fparray[count].stream,fparray[count].want_read);
349         }
350
351       ret = es_poll (fparray, fparraysize, millisecs);
352       if (ret < 0)
353         {
354           err = gpg_error_from_syserror ();
355           log_error ("ldap-reaper failed to poll: %s"
356                      " - waiting 1s\n", gpg_strerror (err));
357           /* In case the reason for the error is a too large array, we
358            * release it so that it will be allocated smaller in the
359            * next round.  */
360           xfree (fparray);
361           fparray = NULL;
362           fparraysize = 0;
363           npth_sleep (1);
364           continue;
365         }
366
367       if (DBG_EXTPROG)
368         {
369           for (count=0; count < fparraysize; count++)
370             if (!fparray[count].ignore)
371               log_debug ("ldap-reaper: fp[%d] stream=%p got=%d\n",
372                          count, fparray[count].stream, fparray[count].got_read);
373         }
374
375       /* All timestamps before exptime should be considered expired.  */
376       exptime = time (NULL);
377       if (exptime > INACTIVITY_TIMEOUT)
378         exptime -= INACTIVITY_TIMEOUT;
379
380       /* Note that there is no need to lock the list because we always
381          add entries at the head (with a pending event status) and
382          thus traversing the list will even work if we have a context
383          switch in waitpid.  */
384       for (ctx = wrapper_list; ctx; ctx = ctx->next)
385         {
386           /* Check whether there is any logging to be done.  We need
387            * to check FPARRAYSIZE because it can be 0 in case es_poll
388            * returned a timeout.  */
389           if (fparraysize && ctx->log_fp && ctx->reaper_idx >= 0)
390             {
391               log_assert (ctx->reaper_idx < fparraysize);
392               if (fparray[ctx->reaper_idx].got_read)
393                 {
394                   if (read_log_data (ctx))
395                     {
396                       SAFE_CLOSE (ctx->log_fp);
397                       any_action = 1;
398                     }
399                 }
400             }
401
402           /* Check whether the process is still running.  */
403           if (ctx->pid != (pid_t)(-1))
404             {
405               int status;
406
407               err = gnupg_wait_process ("[dirmngr_ldap]", ctx->pid, 0,
408                                         &status);
409               if (!err)
410                 {
411                   if (DBG_EXTPROG)
412                     log_info (_("ldap wrapper %d ready"), (int)ctx->pid);
413                   ctx->ready = 1;
414                   gnupg_release_process (ctx->pid);
415                   ctx->pid = (pid_t)(-1);
416                   any_action = 1;
417                 }
418               else if (gpg_err_code (err) == GPG_ERR_GENERAL)
419                 {
420                   if (status == 10)
421                     log_info (_("ldap wrapper %d ready: timeout\n"),
422                               (int)ctx->pid);
423                   else
424                     log_info (_("ldap wrapper %d ready: exitcode=%d\n"),
425                               (int)ctx->pid, status);
426                   ctx->ready = 1;
427                   gnupg_release_process (ctx->pid);
428                   ctx->pid = (pid_t)(-1);
429                   any_action = 1;
430                 }
431               else if (gpg_err_code (err) != GPG_ERR_TIMEOUT)
432                 {
433                   log_error (_("waiting for ldap wrapper %d failed: %s\n"),
434                              (int)ctx->pid, gpg_strerror (err));
435                   any_action = 1;
436                 }
437             }
438
439           /* Check whether we should terminate the process. */
440           if (ctx->pid != (pid_t)(-1)
441               && ctx->stamp != (time_t)(-1) && ctx->stamp < exptime)
442             {
443               gnupg_kill_process (ctx->pid);
444               ctx->stamp = (time_t)(-1);
445               log_info (_("ldap wrapper %d stalled - killing\n"),
446                         (int)ctx->pid);
447               /* We need to close the log stream because the cleanup
448                * loop waits for it.  */
449               SAFE_CLOSE (ctx->log_fp);
450               any_action = 1;
451             }
452         }
453
454       /* If something has been printed to the log file or we got an
455          EOF from a wrapper, we now print the list of active
456          wrappers.  */
457       if (any_action && DBG_EXTPROG)
458         {
459           log_debug ("ldap worker stati:\n");
460           for (ctx = wrapper_list; ctx; ctx = ctx->next)
461             log_debug ("  c=%p pid=%d/%d rdr=%p logfp=%p"
462                        " ctrl=%p/%d la=%lu rdy=%d\n",
463                        ctx,
464                        (int)ctx->pid, (int)ctx->printable_pid,
465                        ctx->reader, ctx->log_fp,
466                        ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0,
467                        (unsigned long)ctx->stamp, ctx->ready);
468         }
469
470
471       /* Use an extra loop to check whether ready marked wrappers may
472        * be removed.  We may only do so if the ksba reader object is
473        * not anymore in use or we are in shutdown state.  */
474      again:
475       for (ctx_prev=NULL, ctx=wrapper_list; ctx; ctx_prev=ctx, ctx=ctx->next)
476         if (ctx->ready
477             && ((!ctx->log_fp && !ctx->reader) || shutting_down))
478           {
479             if (ctx_prev)
480               ctx_prev->next = ctx->next;
481             else
482               wrapper_list = ctx->next;
483             destroy_wrapper (ctx);
484             /* We need to restart because destroy_wrapper might have
485              * done a context switch. */
486             goto again;
487           }
488     }
489   /*NOTREACHED*/
490   return NULL; /* Make the compiler happy.  */
491 }
492
493
494
495 /* Start the reaper thread for the ldap wrapper.  */
496 void
497 ldap_wrapper_launch_thread (void)
498 {
499   static int done;
500   npth_attr_t tattr;
501   npth_t thread;
502   int err;
503
504   if (done)
505     return;
506   done = 1;
507
508   npth_attr_init (&tattr);
509   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
510
511   err = npth_create (&thread, &tattr, ldap_wrapper_thread, NULL);
512   if (err)
513     {
514       log_error (_("error spawning ldap wrapper reaper thread: %s\n"),
515                  strerror (err) );
516       dirmngr_exit (1);
517     }
518   npth_setname_np (thread, "ldap-reaper");
519   npth_attr_destroy (&tattr);
520 }
521
522
523
524 /* Wait until all ldap wrappers have terminated.  We assume that the
525    kill has already been sent to all of them.  */
526 void
527 ldap_wrapper_wait_connections ()
528 {
529   shutting_down = 1;
530   /* FIXME: This is a busy wait.  */
531   while (wrapper_list)
532     npth_usleep (200);
533 }
534
535
536 /* This function is to be used to release a context associated with the
537    given reader object. */
538 void
539 ldap_wrapper_release_context (ksba_reader_t reader)
540 {
541   struct wrapper_context_s *ctx;
542
543   if (!reader )
544     return;
545
546   for (ctx=wrapper_list; ctx; ctx=ctx->next)
547     if (ctx->reader == reader)
548       {
549         if (DBG_EXTPROG)
550           log_debug ("releasing ldap worker c=%p pid=%d/%d rdr=%p ctrl=%p/%d\n",
551                     ctx,
552                     (int)ctx->pid, (int)ctx->printable_pid,
553                     ctx->reader,
554                     ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0);
555
556         ctx->reader = NULL;
557         SAFE_CLOSE (ctx->fp);
558         if (ctx->ctrl)
559           {
560             ctx->ctrl->refcount--;
561             ctx->ctrl = NULL;
562           }
563         if (ctx->fp_err)
564           log_info (_("reading from ldap wrapper %d failed: %s\n"),
565                     ctx->printable_pid, gpg_strerror (ctx->fp_err));
566         break;
567       }
568 }
569
570 /* Cleanup all resources held by the connection associated with
571    CTRL.  This is used after a cancel to kill running wrappers.  */
572 void
573 ldap_wrapper_connection_cleanup (ctrl_t ctrl)
574 {
575   struct wrapper_context_s *ctx;
576
577   for (ctx=wrapper_list; ctx; ctx=ctx->next)
578     if (ctx->ctrl && ctx->ctrl == ctrl)
579       {
580         ctx->ctrl->refcount--;
581         ctx->ctrl = NULL;
582         if (ctx->pid != (pid_t)(-1))
583           gnupg_kill_process (ctx->pid);
584         if (ctx->fp_err)
585           log_info (_("reading from ldap wrapper %d failed: %s\n"),
586                     ctx->printable_pid, gpg_strerror (ctx->fp_err));
587       }
588 }
589
590
591 /* This is the callback used by the ldap wrapper to feed the ksba
592  * reader with the wrapper's stdout.  See the description of
593  * ksba_reader_set_cb for details.  */
594 static int
595 reader_callback (void *cb_value, char *buffer, size_t count,  size_t *nread)
596 {
597   struct wrapper_context_s *ctx = cb_value;
598   size_t nleft = count;
599   struct timespec abstime;
600   struct timespec curtime;
601   struct timespec timeout;
602   int millisecs;
603   gpgrt_poll_t fparray[1];
604   int ret;
605   gpg_error_t err;
606
607
608   /* FIXME: We might want to add some internal buffering because the
609      ksba code does not do any buffering for itself (because a ksba
610      reader may be detached from another stream to read other data and
611      then it would be cumbersome to get back already buffered stuff).  */
612
613   if (!buffer && !count && !nread)
614     return -1; /* Rewind is not supported. */
615
616   /* If we ever encountered a read error, don't continue (we don't want to
617      possibly overwrite the last error cause).  Bail out also if the
618      file descriptor has been closed. */
619   if (ctx->fp_err || !ctx->fp)
620     {
621       *nread = 0;
622       return -1;
623     }
624
625   memset (fparray, 0, sizeof fparray);
626   fparray[0].stream = ctx->fp;
627   fparray[0].want_read = 1;
628
629   npth_clock_gettime (&abstime);
630   abstime.tv_sec += TIMERTICK_INTERVAL;
631
632   while (nleft > 0)
633     {
634       npth_clock_gettime (&curtime);
635       if (!(npth_timercmp (&curtime, &abstime, <)))
636         {
637           err = dirmngr_tick (ctx->ctrl);
638           if (err)
639             {
640               ctx->fp_err = err;
641               SAFE_CLOSE (ctx->fp);
642               return -1;
643             }
644           npth_clock_gettime (&abstime);
645           abstime.tv_sec += TIMERTICK_INTERVAL;
646         }
647       npth_timersub (&abstime, &curtime, &timeout);
648       millisecs = timeout.tv_sec * 1000;
649       millisecs += timeout.tv_nsec / 1000000;
650       if (millisecs < 0)
651         millisecs = 1;
652
653       ret = es_poll (fparray, DIM (fparray), millisecs);
654       if (ret < 0)
655         {
656           ctx->fp_err = gpg_error_from_syserror ();
657           log_error ("error polling stdout of ldap wrapper %d: %s\n",
658                      ctx->printable_pid, gpg_strerror (ctx->fp_err));
659           SAFE_CLOSE (ctx->fp);
660           return -1;
661         }
662       if (!ret)
663         {
664           /* Timeout.  Will be handled when calculating the next timeout.  */
665           continue;
666         }
667
668       if (fparray[0].got_read)
669         {
670           size_t n;
671
672           if (es_read (ctx->fp, buffer, nleft, &n))
673             {
674               ctx->fp_err = gpg_error_from_syserror ();
675               SAFE_CLOSE (ctx->fp);
676               return -1;
677             }
678           else if (!n) /* EOF */
679             {
680               if (nleft == count)
681                 return -1; /* EOF. */
682               break;
683             }
684           nleft -= n;
685           buffer += n;
686           if (n > 0 && ctx->stamp != (time_t)(-1))
687             ctx->stamp = time (NULL);
688         }
689     }
690   *nread = count - nleft;
691
692   return 0;
693 }
694
695
696 /* Fork and exec the LDAP wrapper and return a new libksba reader
697    object at READER.  ARGV is a NULL terminated list of arguments for
698    the wrapper.  The function returns 0 on success or an error code.
699
700    Special hack to avoid passing a password through the command line
701    which is globally visible: If the first element of ARGV is "--pass"
702    it will be removed and instead the environment variable
703    DIRMNGR_LDAP_PASS will be set to the next value of ARGV.  On modern
704    OSes the environment is not visible to other users.  For those old
705    systems where it can't be avoided, we don't want to go into the
706    hassle of passing the password via stdin; it's just too complicated
707    and an LDAP password used for public directory lookups should not
708    be that confidential.  */
709 gpg_error_t
710 ldap_wrapper (ctrl_t ctrl, ksba_reader_t *reader, const char *argv[])
711 {
712   gpg_error_t err;
713   pid_t pid;
714   struct wrapper_context_s *ctx;
715   int i;
716   int j;
717   const char **arg_list;
718   const char *pgmname;
719   estream_t outfp, errfp;
720
721   /* It would be too simple to connect stderr just to our logging
722      stream.  The problem is that if we are running multi-threaded
723      everything gets intermixed.  Clearly we don't want this.  So the
724      only viable solutions are either to have another thread
725      responsible for logging the messages or to add an option to the
726      wrapper module to do the logging on its own.  Given that we anyway
727      need a way to reap the child process and this is best done using a
728      general reaping thread, that thread can do the logging too. */
729   ldap_wrapper_launch_thread ();
730
731   *reader = NULL;
732
733   /* Files: We need to prepare stdin and stdout.  We get stderr from
734      the function.  */
735   if (!opt.ldap_wrapper_program || !*opt.ldap_wrapper_program)
736     pgmname = gnupg_module_name (GNUPG_MODULE_NAME_DIRMNGR_LDAP);
737   else
738     pgmname = opt.ldap_wrapper_program;
739
740   /* Create command line argument array.  */
741   for (i = 0; argv[i]; i++)
742     ;
743   arg_list = xtrycalloc (i + 2, sizeof *arg_list);
744   if (!arg_list)
745     {
746       err = gpg_error_from_syserror ();
747       log_error (_("error allocating memory: %s\n"), strerror (errno));
748       return err;
749     }
750   for (i = j = 0; argv[i]; i++, j++)
751     if (!i && argv[i + 1] && !strcmp (*argv, "--pass"))
752       {
753         arg_list[j] = "--env-pass";
754         setenv ("DIRMNGR_LDAP_PASS", argv[1], 1);
755         i++;
756       }
757     else
758       arg_list[j] = (char*) argv[i];
759
760   ctx = xtrycalloc (1, sizeof *ctx);
761   if (!ctx)
762     {
763       err = gpg_error_from_syserror ();
764       log_error (_("error allocating memory: %s\n"), strerror (errno));
765       xfree (arg_list);
766       return err;
767     }
768
769   err = gnupg_spawn_process (pgmname, arg_list,
770                              NULL, NULL, GNUPG_SPAWN_NONBLOCK,
771                              NULL, &outfp, &errfp, &pid);
772   xfree (arg_list);
773   if (err)
774     {
775       xfree (ctx);
776       log_error ("error running '%s': %s\n", pgmname, gpg_strerror (err));
777       return err;
778     }
779
780   ctx->pid = pid;
781   ctx->printable_pid = (int) pid;
782   ctx->fp = outfp;
783   ctx->log_fp = errfp;
784   ctx->ctrl = ctrl;
785   ctrl->refcount++;
786   ctx->stamp = time (NULL);
787
788   err = ksba_reader_new (reader);
789   if (!err)
790     err = ksba_reader_set_cb (*reader, reader_callback, ctx);
791   if (err)
792     {
793       log_error (_("error initializing reader object: %s\n"),
794                  gpg_strerror (err));
795       destroy_wrapper (ctx);
796       ksba_reader_release (*reader);
797       *reader = NULL;
798       return err;
799     }
800
801   /* Hook the context into our list of running wrappers.  */
802   ctx->reader = *reader;
803   ctx->next = wrapper_list;
804   wrapper_list = ctx;
805   if (DBG_EXTPROG)
806     log_debug ("ldap wrapper %d started (%p, %s)\n",
807                (int)ctx->pid, ctx->reader, pgmname);
808
809   /* Need to wait for the first byte so we are able to detect an empty
810      output and not let the consumer see an EOF without further error
811      indications.  The CRL loading logic assumes that after return
812      from this function, a failed search (e.g. host not found ) is
813      indicated right away. */
814   {
815     unsigned char c;
816
817     err = read_buffer (*reader, &c, 1);
818     if (err)
819       {
820         ldap_wrapper_release_context (*reader);
821         ksba_reader_release (*reader);
822         *reader = NULL;
823         if (gpg_err_code (err) == GPG_ERR_EOF)
824           return gpg_error (GPG_ERR_NO_DATA);
825         else
826           return err;
827       }
828     ksba_reader_unread (*reader, &c, 1);
829   }
830
831   return 0;
832 }