dirmngr: Add missing cast for use of pid_t in printf.
[gnupg.git] / dirmngr / ldap-wrapper.c
1 /* ldap-wrapper.c - LDAP access via a wrapper process
2  * Copyright (C) 2004, 2005, 2007, 2008 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 <http://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 PTh.
26
27    2. It is huge library in particular if TLS comes into play.  So
28       problems with unfreed memory might turn up and we don't want
29       this in a long running daemon.
30
31    3. There is no easy way for timeouts. In particular the timeout
32       value does not work for DNS lookups (well, this is usual) and it
33       seems not to work while loading a large attribute like a
34       CRL. Having a separate process allows us to either tell the
35       process to commit suicide or have our own housekepping function
36       kill it after some time.  The latter also allows proper
37       cancellation of a query at any point of time.
38
39    4. Given that we are going out to the network and usually get back
40       a long response, the fork/exec overhead is acceptable.
41
42    Note that under WindowsCE the number of processes is strongly
43    limited (32 processes including the kernel processes) and thus we
44    don't use the process approach but implement a different wrapper in
45    ldap-wrapper-ce.c.
46 */
47
48
49 #include <config.h>
50
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54 #include <errno.h>
55 #include <unistd.h>
56 #include <fcntl.h>
57 #include <time.h>
58 #include <npth.h>
59
60 #include "dirmngr.h"
61 #include "exechelp.h"
62 #include "misc.h"
63 #include "ldap-wrapper.h"
64
65
66 #ifdef HAVE_W32_SYSTEM
67 #define setenv(a,b,c) SetEnvironmentVariable ((a),(b))
68 #else
69 #define pth_close(fd) close(fd)
70 #endif
71
72 #ifndef USE_LDAPWRAPPER
73 # error This module is not expected to be build.
74 #endif
75
76 /* In case sysconf does not return a value we need to have a limit. */
77 #ifdef _POSIX_OPEN_MAX
78 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
79 #else
80 #define MAX_OPEN_FDS 20
81 #endif
82
83 #define INACTIVITY_TIMEOUT (opt.ldaptimeout + 60*5)  /* seconds */
84
85 #define TIMERTICK_INTERVAL 2
86
87 /* To keep track of the LDAP wrapper state we use this structure.  */
88 struct wrapper_context_s
89 {
90   struct wrapper_context_s *next;
91
92   pid_t pid;    /* The pid of the wrapper process. */
93   int printable_pid; /* Helper to print diagnostics after the process has
94                         been cleaned up. */
95   int fd;       /* Connected with stdout of the ldap wrapper.  */
96   gpg_error_t fd_error; /* Set to the gpg_error of the last read error
97                            if any.  */
98   int log_fd;   /* Connected with stderr of the ldap wrapper.  */
99   ctrl_t ctrl;  /* Connection data. */
100   int ready;    /* Internally used to mark to be removed contexts. */
101   ksba_reader_t reader; /* The ksba reader object or NULL. */
102   char *line;     /* Used to print the log lines (malloced). */
103   size_t linesize;/* Allocated size of LINE.  */
104   size_t linelen; /* Use size of LINE.  */
105   time_t stamp;   /* The last time we noticed ativity.  */
106 };
107
108
109
110 /* We keep a global list of spawed wrapper process.  A separate thread
111    makes use of this list to log error messages and to watch out for
112    finished processes. */
113 static struct wrapper_context_s *wrapper_list;
114
115 /* We need to know whether we are shutting down the process.  */
116 static int shutting_down;
117
118 /* Close the pth file descriptor FD and set it to -1.  */
119 #define SAFE_CLOSE(fd) \
120   do { int _fd = fd; if (_fd != -1) { close (_fd); fd = -1;} } while (0)
121
122
123
124 \f
125 /* Read a fixed amount of data from READER into BUFFER.  */
126 static gpg_error_t
127 read_buffer (ksba_reader_t reader, unsigned char *buffer, size_t count)
128 {
129   gpg_error_t err;
130   size_t nread;
131
132   while (count)
133     {
134       err = ksba_reader_read (reader, buffer, count, &nread);
135       if (err)
136         return err;
137       buffer += nread;
138       count -= nread;
139     }
140   return 0;
141 }
142
143
144 /* Release the wrapper context and kill a running wrapper process. */
145 static void
146 destroy_wrapper (struct wrapper_context_s *ctx)
147 {
148   if (ctx->pid != (pid_t)(-1))
149     {
150       gnupg_kill_process (ctx->pid);
151       gnupg_release_process (ctx->pid);
152     }
153   ksba_reader_release (ctx->reader);
154   SAFE_CLOSE (ctx->fd);
155   SAFE_CLOSE (ctx->log_fd);
156   xfree (ctx->line);
157   xfree (ctx);
158 }
159
160
161 /* Print the content of LINE to thye log stream but make sure to only
162    print complete lines.  Using NULL for LINE will flush any pending
163    output.  LINE may be modified by this fucntion. */
164 static void
165 print_log_line (struct wrapper_context_s *ctx, char *line)
166 {
167   char *s;
168   size_t n;
169
170   if (!line)
171     {
172       if (ctx->line && ctx->linelen)
173         {
174
175           log_info ("%s\n", ctx->line);
176           ctx->linelen = 0;
177         }
178       return;
179     }
180
181   while ((s = strchr (line, '\n')))
182     {
183       *s = 0;
184       if (ctx->line && ctx->linelen)
185         {
186           log_info ("%s", ctx->line);
187           ctx->linelen = 0;
188           log_printf ("%s\n", line);
189         }
190       else
191         log_info ("%s\n", line);
192       line = s + 1;
193     }
194   n = strlen (line);
195   if (n)
196     {
197       if (ctx->linelen + n + 1 >= ctx->linesize)
198         {
199           char *tmp;
200           size_t newsize;
201
202           newsize = ctx->linesize + ((n + 255) & ~255) + 1;
203           tmp = (ctx->line ? xtryrealloc (ctx->line, newsize)
204                            : xtrymalloc (newsize));
205           if (!tmp)
206             {
207               log_error (_("error printing log line: %s\n"), strerror (errno));
208               return;
209             }
210           ctx->line = tmp;
211           ctx->linesize = newsize;
212         }
213       memcpy (ctx->line + ctx->linelen, line, n);
214       ctx->linelen += n;
215       ctx->line[ctx->linelen] = 0;
216     }
217 }
218
219
220 /* Read data from the log stream.  Returns true if the log stream
221    indicated EOF or error.  */
222 static int
223 read_log_data (struct wrapper_context_s *ctx)
224 {
225   int n;
226   char line[256];
227
228   /* We must use the npth_read function for pipes, always.  */
229   do
230     n = npth_read (ctx->log_fd, line, sizeof line - 1);
231   while (n < 0 && errno == EINTR);
232
233   if (n <= 0) /* EOF or error. */
234     {
235       if (n < 0)
236         log_error (_("error reading log from ldap wrapper %d: %s\n"),
237                    (int)ctx->pid, strerror (errno));
238       print_log_line (ctx, NULL);
239       SAFE_CLOSE (ctx->log_fd);
240       return 1;
241     }
242
243   line[n] = 0;
244   print_log_line (ctx, line);
245   if (ctx->stamp != (time_t)(-1))
246     ctx->stamp = time (NULL);
247   return 0;
248 }
249
250
251 /* This function is run by a separate thread to maintain the list of
252    wrappers and to log error messages from these wrappers.  */
253 void *
254 ldap_wrapper_thread (void *dummy)
255 {
256   int nfds;
257   struct wrapper_context_s *ctx;
258   struct wrapper_context_s *ctx_prev;
259   struct timespec abstime;
260   struct timespec curtime;
261   struct timespec timeout;
262   int saved_errno;
263   fd_set fdset, read_fdset;
264   int ret;
265   time_t exptime;
266
267   (void)dummy;
268
269   FD_ZERO (&fdset);
270   nfds = -1;
271   for (ctx = wrapper_list; ctx; ctx = ctx->next)
272     {
273       if (ctx->log_fd != -1)
274         {
275           FD_SET (ctx->log_fd, &fdset);
276           if (ctx->log_fd > nfds)
277             nfds = ctx->log_fd;
278         }
279     }
280   nfds++;
281
282   npth_clock_gettime (&abstime);
283   abstime.tv_sec += TIMERTICK_INTERVAL;
284
285   for (;;)
286     {
287       int any_action = 0;
288
289       /* POSIX says that fd_set should be implemented as a structure,
290          thus a simple assignment is fine to copy the entire set.  */
291       read_fdset = fdset;
292
293       npth_clock_gettime (&curtime);
294       if (!(npth_timercmp (&curtime, &abstime, <)))
295         {
296           /* Inactivity is checked below.  Nothing else to do.  */
297           // handle_tick ();
298           npth_clock_gettime (&abstime);
299           abstime.tv_sec += TIMERTICK_INTERVAL;
300         }
301       npth_timersub (&abstime, &curtime, &timeout);
302
303       /* FIXME: For Windows, we have to use a reader thread on the
304          pipe that signals an event (and a npth_select_ev variant).  */
305       ret = npth_pselect (nfds + 1, &read_fdset, NULL, NULL, &timeout, NULL);
306       saved_errno = errno;
307
308       if (ret == -1 && saved_errno != EINTR)
309         {
310           log_error (_("npth_select failed: %s - waiting 1s\n"),
311                      strerror (saved_errno));
312           npth_sleep (1);
313           continue;
314         }
315
316       if (ret <= 0)
317         /* Interrupt or timeout.  Will be handled when calculating the
318            next timeout.  */
319         continue;
320
321       /* All timestamps before exptime should be considered expired.  */
322       exptime = time (NULL);
323       if (exptime > INACTIVITY_TIMEOUT)
324         exptime -= INACTIVITY_TIMEOUT;
325
326       /* Note that there is no need to lock the list because we always
327          add entries at the head (with a pending event status) and
328          thus traversing the list will even work if we have a context
329          switch in waitpid (which should anyway only happen with Pth's
330          hard system call mapping).  */
331       for (ctx = wrapper_list; ctx; ctx = ctx->next)
332         {
333           /* Check whether there is any logging to be done. */
334           if (nfds && ctx->log_fd != -1 && FD_ISSET (ctx->log_fd, &read_fdset))
335             {
336               if (read_log_data (ctx))
337                 any_action = 1;
338             }
339
340           /* Check whether the process is still running.  */
341           if (ctx->pid != (pid_t)(-1))
342             {
343               gpg_error_t err;
344               int status;
345
346               err = gnupg_wait_process ("[dirmngr_ldap]", ctx->pid, 0,
347                                         &status);
348               if (!err)
349                 {
350                   log_info (_("ldap wrapper %d ready"), (int)ctx->pid);
351                   ctx->ready = 1;
352                   gnupg_release_process (ctx->pid);
353                   ctx->pid = (pid_t)(-1);
354                   any_action = 1;
355                 }
356               else if (gpg_err_code (err) == GPG_ERR_GENERAL)
357                 {
358                   if (status == 10)
359                     log_info (_("ldap wrapper %d ready: timeout\n"),
360                               (int)ctx->pid);
361                   else
362                     log_info (_("ldap wrapper %d ready: exitcode=%d\n"),
363                               (int)ctx->pid, status);
364                   ctx->ready = 1;
365                   gnupg_release_process (ctx->pid);
366                   ctx->pid = (pid_t)(-1);
367                   any_action = 1;
368                 }
369               else if (gpg_err_code (err) != GPG_ERR_TIMEOUT)
370                 {
371                   log_error (_("waiting for ldap wrapper %d failed: %s\n"),
372                              (int)ctx->pid, gpg_strerror (err));
373                   any_action = 1;
374                 }
375             }
376
377           /* Check whether we should terminate the process. */
378           if (ctx->pid != (pid_t)(-1)
379               && ctx->stamp != (time_t)(-1) && ctx->stamp < exptime)
380             {
381               gnupg_kill_process (ctx->pid);
382               ctx->stamp = (time_t)(-1);
383               log_info (_("ldap wrapper %d stalled - killing\n"),
384                         (int)ctx->pid);
385               /* We need to close the log fd because the cleanup loop
386                  waits for it.  */
387               SAFE_CLOSE (ctx->log_fd);
388               any_action = 1;
389             }
390         }
391
392       /* If something has been printed to the log file or we got an
393          EOF from a wrapper, we now print the list of active
394          wrappers.  */
395       if (any_action && DBG_LOOKUP)
396         {
397           log_info ("ldap worker stati:\n");
398           for (ctx = wrapper_list; ctx; ctx = ctx->next)
399             log_info ("  c=%p pid=%d/%d rdr=%p ctrl=%p/%d la=%lu rdy=%d\n",
400                       ctx,
401                       (int)ctx->pid, (int)ctx->printable_pid,
402                       ctx->reader,
403                       ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0,
404                       (unsigned long)ctx->stamp, ctx->ready);
405         }
406
407
408       /* Use a separate loop to check whether ready marked wrappers
409          may be removed.  We may only do so if the ksba reader object
410          is not anymore in use or we are in shutdown state.  */
411      again:
412       for (ctx_prev=NULL, ctx=wrapper_list; ctx; ctx_prev=ctx, ctx=ctx->next)
413         if (ctx->ready
414             && ((ctx->log_fd == -1 && !ctx->reader) || shutting_down))
415           {
416             if (ctx_prev)
417               ctx_prev->next = ctx->next;
418             else
419               wrapper_list = ctx->next;
420             destroy_wrapper (ctx);
421             /* We need to restart because destroy_wrapper might have
422                done a context switch. */
423             goto again;
424           }
425     }
426   /*NOTREACHED*/
427   return NULL; /* Make the compiler happy.  */
428 }
429
430
431
432 /* Start the reaper thread for the ldap wrapper.  */
433 void
434 ldap_wrapper_launch_thread (void)
435 {
436   static int done;
437   npth_attr_t tattr;
438   npth_t thread;
439   int err;
440
441   if (done)
442     return;
443   done = 1;
444
445   npth_attr_init (&tattr);
446   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
447
448   err = npth_create (&thread, &tattr, ldap_wrapper_thread, NULL);
449   if (err)
450     {
451       log_error (_("error spawning ldap wrapper reaper thread: %s\n"),
452                  strerror (err) );
453       dirmngr_exit (1);
454     }
455   npth_setname_np (thread, "ldap-reaper");
456   npth_attr_destroy (&tattr);
457 }
458
459
460
461
462
463 /* Wait until all ldap wrappers have terminated.  We assume that the
464    kill has already been sent to all of them.  */
465 void
466 ldap_wrapper_wait_connections ()
467 {
468   shutting_down = 1;
469   /* FIXME: This is a busy wait.  */
470   while (wrapper_list)
471     npth_usleep (200);
472 }
473
474
475 /* This function is to be used to release a context associated with the
476    given reader object. */
477 void
478 ldap_wrapper_release_context (ksba_reader_t reader)
479 {
480   struct wrapper_context_s *ctx;
481
482   if (!reader )
483     return;
484
485   for (ctx=wrapper_list; ctx; ctx=ctx->next)
486     if (ctx->reader == reader)
487       {
488         if (DBG_LOOKUP)
489           log_info ("releasing ldap worker c=%p pid=%d/%d rdr=%p ctrl=%p/%d\n",
490                     ctx,
491                     (int)ctx->pid, (int)ctx->printable_pid,
492                     ctx->reader,
493                     ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0);
494
495         ctx->reader = NULL;
496         SAFE_CLOSE (ctx->fd);
497         if (ctx->ctrl)
498           {
499             ctx->ctrl->refcount--;
500             ctx->ctrl = NULL;
501           }
502         if (ctx->fd_error)
503           log_info (_("reading from ldap wrapper %d failed: %s\n"),
504                     ctx->printable_pid, gpg_strerror (ctx->fd_error));
505         break;
506       }
507 }
508
509 /* Cleanup all resources held by the connection associated with
510    CTRL.  This is used after a cancel to kill running wrappers.  */
511 void
512 ldap_wrapper_connection_cleanup (ctrl_t ctrl)
513 {
514   struct wrapper_context_s *ctx;
515
516   for (ctx=wrapper_list; ctx; ctx=ctx->next)
517     if (ctx->ctrl && ctx->ctrl == ctrl)
518       {
519         ctx->ctrl->refcount--;
520         ctx->ctrl = NULL;
521         if (ctx->pid != (pid_t)(-1))
522           gnupg_kill_process (ctx->pid);
523         if (ctx->fd_error)
524           log_info (_("reading from ldap wrapper %d failed: %s\n"),
525                     ctx->printable_pid, gpg_strerror (ctx->fd_error));
526       }
527 }
528
529
530 /* This is the callback used by the ldap wrapper to feed the ksba
531    reader with the wrappers stdout.  See the description of
532    ksba_reader_set_cb for details.  */
533 static int
534 reader_callback (void *cb_value, char *buffer, size_t count,  size_t *nread)
535 {
536   struct wrapper_context_s *ctx = cb_value;
537   size_t nleft = count;
538   int nfds;
539   struct timespec abstime;
540   struct timespec curtime;
541   struct timespec timeout;
542   int saved_errno;
543   fd_set fdset, read_fdset;
544   int ret;
545
546   /* FIXME: We might want to add some internal buffering because the
547      ksba code does not do any buffering for itself (because a ksba
548      reader may be detached from another stream to read other data and
549      the it would be cumbersome to get back already buffered
550      stuff).  */
551
552   if (!buffer && !count && !nread)
553     return -1; /* Rewind is not supported. */
554
555   /* If we ever encountered a read error don't allow to continue and
556      possible overwrite the last error cause.  Bail out also if the
557      file descriptor has been closed. */
558   if (ctx->fd_error || ctx->fd == -1)
559     {
560       *nread = 0;
561       return -1;
562     }
563
564   FD_ZERO (&fdset);
565   FD_SET (ctx->fd, &fdset);
566   nfds = ctx->fd + 1;
567
568   npth_clock_gettime (&abstime);
569   abstime.tv_sec += TIMERTICK_INTERVAL;
570
571   while (nleft > 0)
572     {
573       int n;
574       gpg_error_t err;
575
576       npth_clock_gettime (&curtime);
577       if (!(npth_timercmp (&curtime, &abstime, <)))
578         {
579           err = dirmngr_tick (ctx->ctrl);
580           if (err)
581             {
582               ctx->fd_error = err;
583               SAFE_CLOSE (ctx->fd);
584               return -1;
585             }
586           npth_clock_gettime (&abstime);
587           abstime.tv_sec += TIMERTICK_INTERVAL;
588         }
589       npth_timersub (&abstime, &curtime, &timeout);
590
591       read_fdset = fdset;
592       ret = npth_pselect (nfds, &read_fdset, NULL, NULL, &timeout, NULL);
593       saved_errno = errno;
594
595       if (ret == -1 && saved_errno != EINTR)
596         {
597           ctx->fd_error = gpg_error_from_errno (errno);
598           SAFE_CLOSE (ctx->fd);
599           return -1;
600         }
601       if (ret <= 0)
602         /* Timeout.  Will be handled when calculating the next timeout.  */
603         continue;
604
605       /* This should not block now that select returned with a file
606          descriptor.  So it shouldn't be necessary to use npth_read
607          (and it is slightly dangerous in the sense that a concurrent
608          thread might (accidentially?) change the status of ctx->fd
609          before we read.  FIXME: Set ctx->fd to nonblocking?  */
610       n = read (ctx->fd, buffer, nleft);
611       if (n < 0)
612         {
613           ctx->fd_error = gpg_error_from_errno (errno);
614           SAFE_CLOSE (ctx->fd);
615           return -1;
616         }
617       else if (!n)
618         {
619           if (nleft == count)
620             return -1; /* EOF. */
621           break;
622         }
623       nleft -= n;
624       buffer += n;
625       if (n > 0 && ctx->stamp != (time_t)(-1))
626         ctx->stamp = time (NULL);
627     }
628   *nread = count - nleft;
629
630   return 0;
631 }
632
633 /* Fork and exec the LDAP wrapper and return a new libksba reader
634    object at READER.  ARGV is a NULL terminated list of arguments for
635    the wrapper.  The function returns 0 on success or an error code.
636
637    Special hack to avoid passing a password through the command line
638    which is globally visible: If the first element of ARGV is "--pass"
639    it will be removed and instead the environment variable
640    DIRMNGR_LDAP_PASS will be set to the next value of ARGV.  On modern
641    OSes the environment is not visible to other users.  For those old
642    systems where it can't be avoided, we don't want to go into the
643    hassle of passing the password via stdin; it's just too complicated
644    and an LDAP password used for public directory lookups should not
645    be that confidential.  */
646 gpg_error_t
647 ldap_wrapper (ctrl_t ctrl, ksba_reader_t *reader, const char *argv[])
648 {
649   gpg_error_t err;
650   pid_t pid;
651   struct wrapper_context_s *ctx;
652   int i;
653   int j;
654   const char **arg_list;
655   const char *pgmname;
656   int outpipe[2], errpipe[2];
657
658   /* It would be too simple to connect stderr just to our logging
659      stream.  The problem is that if we are running multi-threaded
660      everything gets intermixed.  Clearly we don't want this.  So the
661      only viable solutions are either to have another thread
662      responsible for logging the messages or to add an option to the
663      wrapper module to do the logging on its own.  Given that we anyway
664      need a way to rip the child process and this is best done using a
665      general ripping thread, that thread can do the logging too. */
666
667   *reader = NULL;
668
669   /* Files: We need to prepare stdin and stdout.  We get stderr from
670      the function.  */
671   if (!opt.ldap_wrapper_program || !*opt.ldap_wrapper_program)
672     pgmname = gnupg_module_name (GNUPG_MODULE_NAME_DIRMNGR_LDAP);
673   else
674     pgmname = opt.ldap_wrapper_program;
675
676   /* Create command line argument array.  */
677   for (i = 0; argv[i]; i++)
678     ;
679   arg_list = xtrycalloc (i + 2, sizeof *arg_list);
680   if (!arg_list)
681     {
682       err = gpg_error_from_syserror ();
683       log_error (_("error allocating memory: %s\n"), strerror (errno));
684       return err;
685     }
686   for (i = j = 0; argv[i]; i++, j++)
687     if (!i && argv[i + 1] && !strcmp (*argv, "--pass"))
688       {
689         arg_list[j] = "--env-pass";
690         setenv ("DIRMNGR_LDAP_PASS", argv[1], 1);
691         i++;
692       }
693     else
694       arg_list[j] = (char*) argv[i];
695
696   ctx = xtrycalloc (1, sizeof *ctx);
697   if (!ctx)
698     {
699       err = gpg_error_from_syserror ();
700       log_error (_("error allocating memory: %s\n"), strerror (errno));
701       xfree (arg_list);
702       return err;
703     }
704
705   err = gnupg_create_inbound_pipe (outpipe);
706   if (!err)
707     {
708       err = gnupg_create_inbound_pipe (errpipe);
709       if (err)
710         {
711           close (outpipe[0]);
712           close (outpipe[1]);
713         }
714     }
715   if (err)
716     {
717       log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
718       xfree (arg_list);
719       xfree (ctx);
720       return err;
721     }
722
723   err = gnupg_spawn_process_fd (pgmname, arg_list,
724                                 -1, outpipe[1], errpipe[1], &pid);
725   xfree (arg_list);
726   close (outpipe[1]);
727   close (errpipe[1]);
728   if (err)
729     {
730       close (outpipe[0]);
731       close (errpipe[0]);
732       xfree (ctx);
733       return err;
734     }
735
736   ctx->pid = pid;
737   ctx->printable_pid = (int) pid;
738   ctx->fd = outpipe[0];
739   ctx->log_fd = errpipe[0];
740   ctx->ctrl = ctrl;
741   ctrl->refcount++;
742   ctx->stamp = time (NULL);
743
744   err = ksba_reader_new (reader);
745   if (!err)
746     err = ksba_reader_set_cb (*reader, reader_callback, ctx);
747   if (err)
748     {
749       log_error (_("error initializing reader object: %s\n"),
750                  gpg_strerror (err));
751       destroy_wrapper (ctx);
752       ksba_reader_release (*reader);
753       *reader = NULL;
754       return err;
755     }
756
757   /* Hook the context into our list of running wrappers.  */
758   ctx->reader = *reader;
759   ctx->next = wrapper_list;
760   wrapper_list = ctx;
761   if (opt.verbose)
762     log_info ("ldap wrapper %d started (reader %p)\n",
763               (int)ctx->pid, ctx->reader);
764
765   /* Need to wait for the first byte so we are able to detect an empty
766      output and not let the consumer see an EOF without further error
767      indications.  The CRL loading logic assumes that after return
768      from this function, a failed search (e.g. host not found ) is
769      indicated right away. */
770   {
771     unsigned char c;
772
773     err = read_buffer (*reader, &c, 1);
774     if (err)
775       {
776         ldap_wrapper_release_context (*reader);
777         ksba_reader_release (*reader);
778         *reader = NULL;
779         if (gpg_err_code (err) == GPG_ERR_EOF)
780           return gpg_error (GPG_ERR_NO_DATA);
781         else
782           return err;
783       }
784     ksba_reader_unread (*reader, &c, 1);
785   }
786
787   return 0;
788 }