dirmngr: Cleanup zombies and fix hang on shutdown.
[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   fd_set fdset;
263   int ret;
264   time_t exptime;
265
266   (void)dummy;
267
268   npth_clock_gettime (&abstime);
269   abstime.tv_sec += TIMERTICK_INTERVAL;
270
271   for (;;)
272     {
273       int any_action = 0;
274
275       npth_clock_gettime (&curtime);
276       if (!(npth_timercmp (&curtime, &abstime, <)))
277         {
278           /* Inactivity is checked below.  Nothing else to do.  */
279           npth_clock_gettime (&abstime);
280           abstime.tv_sec += TIMERTICK_INTERVAL;
281         }
282       npth_timersub (&abstime, &curtime, &timeout);
283
284       FD_ZERO (&fdset);
285       nfds = -1;
286       for (ctx = wrapper_list; ctx; ctx = ctx->next)
287         {
288           if (ctx->log_fd != -1)
289             {
290               FD_SET (ctx->log_fd, &fdset);
291               if (ctx->log_fd > nfds)
292                 nfds = ctx->log_fd;
293             }
294         }
295       nfds++;
296
297       /* FIXME: For Windows, we have to use a reader thread on the
298          pipe that signals an event (and a npth_select_ev variant).  */
299       ret = npth_pselect (nfds + 1, &fdset, NULL, NULL, &timeout, NULL);
300       if (ret == -1)
301         {
302           if (errno != EINTR)
303             {
304               log_error (_("npth_select failed: %s - waiting 1s\n"),
305                          strerror (errno));
306               npth_sleep (1);
307             }
308           continue;
309         }
310
311       /* All timestamps before exptime should be considered expired.  */
312       exptime = time (NULL);
313       if (exptime > INACTIVITY_TIMEOUT)
314         exptime -= INACTIVITY_TIMEOUT;
315
316       /* Note that there is no need to lock the list because we always
317          add entries at the head (with a pending event status) and
318          thus traversing the list will even work if we have a context
319          switch in waitpid (which should anyway only happen with Pth's
320          hard system call mapping).  */
321       for (ctx = wrapper_list; ctx; ctx = ctx->next)
322         {
323           /* Check whether there is any logging to be done. */
324           if (nfds && ctx->log_fd != -1 && FD_ISSET (ctx->log_fd, &fdset))
325             {
326               if (read_log_data (ctx))
327                 {
328                   ksba_reader_release (ctx->reader);
329                   ctx->reader = NULL;
330                   SAFE_CLOSE (ctx->log_fd);
331                   any_action = 1;
332                 }
333             }
334
335           /* Check whether the process is still running.  */
336           if (ctx->pid != (pid_t)(-1))
337             {
338               gpg_error_t err;
339               int status;
340
341               err = gnupg_wait_process ("[dirmngr_ldap]", ctx->pid, 0,
342                                         &status);
343               if (!err)
344                 {
345                   log_info (_("ldap wrapper %d ready"), (int)ctx->pid);
346                   ctx->ready = 1;
347                   gnupg_release_process (ctx->pid);
348                   ctx->pid = (pid_t)(-1);
349                   any_action = 1;
350                 }
351               else if (gpg_err_code (err) == GPG_ERR_GENERAL)
352                 {
353                   if (status == 10)
354                     log_info (_("ldap wrapper %d ready: timeout\n"),
355                               (int)ctx->pid);
356                   else
357                     log_info (_("ldap wrapper %d ready: exitcode=%d\n"),
358                               (int)ctx->pid, status);
359                   ctx->ready = 1;
360                   gnupg_release_process (ctx->pid);
361                   ctx->pid = (pid_t)(-1);
362                   any_action = 1;
363                 }
364               else if (gpg_err_code (err) != GPG_ERR_TIMEOUT)
365                 {
366                   log_error (_("waiting for ldap wrapper %d failed: %s\n"),
367                              (int)ctx->pid, gpg_strerror (err));
368                   any_action = 1;
369                 }
370             }
371
372           /* Check whether we should terminate the process. */
373           if (ctx->pid != (pid_t)(-1)
374               && ctx->stamp != (time_t)(-1) && ctx->stamp < exptime)
375             {
376               gnupg_kill_process (ctx->pid);
377               ctx->stamp = (time_t)(-1);
378               log_info (_("ldap wrapper %d stalled - killing\n"),
379                         (int)ctx->pid);
380               /* We need to close the log fd because the cleanup loop
381                  waits for it.  */
382               SAFE_CLOSE (ctx->log_fd);
383               any_action = 1;
384             }
385         }
386
387       /* If something has been printed to the log file or we got an
388          EOF from a wrapper, we now print the list of active
389          wrappers.  */
390       if (any_action && DBG_LOOKUP)
391         {
392           log_info ("ldap worker stati:\n");
393           for (ctx = wrapper_list; ctx; ctx = ctx->next)
394             log_info ("  c=%p pid=%d/%d rdr=%p ctrl=%p/%d la=%lu rdy=%d\n",
395                       ctx,
396                       (int)ctx->pid, (int)ctx->printable_pid,
397                       ctx->reader,
398                       ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0,
399                       (unsigned long)ctx->stamp, ctx->ready);
400         }
401
402
403       /* Use a separate loop to check whether ready marked wrappers
404          may be removed.  We may only do so if the ksba reader object
405          is not anymore in use or we are in shutdown state.  */
406      again:
407       for (ctx_prev=NULL, ctx=wrapper_list; ctx; ctx_prev=ctx, ctx=ctx->next)
408         if (ctx->ready
409             && ((ctx->log_fd == -1 && !ctx->reader) || shutting_down))
410           {
411             if (ctx_prev)
412               ctx_prev->next = ctx->next;
413             else
414               wrapper_list = ctx->next;
415             destroy_wrapper (ctx);
416             /* We need to restart because destroy_wrapper might have
417                done a context switch. */
418             goto again;
419           }
420     }
421   /*NOTREACHED*/
422   return NULL; /* Make the compiler happy.  */
423 }
424
425
426
427 /* Start the reaper thread for the ldap wrapper.  */
428 void
429 ldap_wrapper_launch_thread (void)
430 {
431   static int done;
432   npth_attr_t tattr;
433   npth_t thread;
434   int err;
435
436   if (done)
437     return;
438   done = 1;
439
440   npth_attr_init (&tattr);
441   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
442
443   err = npth_create (&thread, &tattr, ldap_wrapper_thread, NULL);
444   if (err)
445     {
446       log_error (_("error spawning ldap wrapper reaper thread: %s\n"),
447                  strerror (err) );
448       dirmngr_exit (1);
449     }
450   npth_setname_np (thread, "ldap-reaper");
451   npth_attr_destroy (&tattr);
452 }
453
454
455
456
457
458 /* Wait until all ldap wrappers have terminated.  We assume that the
459    kill has already been sent to all of them.  */
460 void
461 ldap_wrapper_wait_connections ()
462 {
463   shutting_down = 1;
464   /* FIXME: This is a busy wait.  */
465   while (wrapper_list)
466     npth_usleep (200);
467 }
468
469
470 /* This function is to be used to release a context associated with the
471    given reader object. */
472 void
473 ldap_wrapper_release_context (ksba_reader_t reader)
474 {
475   struct wrapper_context_s *ctx;
476
477   if (!reader )
478     return;
479
480   for (ctx=wrapper_list; ctx; ctx=ctx->next)
481     if (ctx->reader == reader)
482       {
483         if (DBG_LOOKUP)
484           log_info ("releasing ldap worker c=%p pid=%d/%d rdr=%p ctrl=%p/%d\n",
485                     ctx,
486                     (int)ctx->pid, (int)ctx->printable_pid,
487                     ctx->reader,
488                     ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0);
489
490         ctx->reader = NULL;
491         SAFE_CLOSE (ctx->fd);
492         if (ctx->ctrl)
493           {
494             ctx->ctrl->refcount--;
495             ctx->ctrl = NULL;
496           }
497         if (ctx->fd_error)
498           log_info (_("reading from ldap wrapper %d failed: %s\n"),
499                     ctx->printable_pid, gpg_strerror (ctx->fd_error));
500         break;
501       }
502 }
503
504 /* Cleanup all resources held by the connection associated with
505    CTRL.  This is used after a cancel to kill running wrappers.  */
506 void
507 ldap_wrapper_connection_cleanup (ctrl_t ctrl)
508 {
509   struct wrapper_context_s *ctx;
510
511   for (ctx=wrapper_list; ctx; ctx=ctx->next)
512     if (ctx->ctrl && ctx->ctrl == ctrl)
513       {
514         ctx->ctrl->refcount--;
515         ctx->ctrl = NULL;
516         if (ctx->pid != (pid_t)(-1))
517           gnupg_kill_process (ctx->pid);
518         if (ctx->fd_error)
519           log_info (_("reading from ldap wrapper %d failed: %s\n"),
520                     ctx->printable_pid, gpg_strerror (ctx->fd_error));
521       }
522 }
523
524
525 /* This is the callback used by the ldap wrapper to feed the ksba
526    reader with the wrappers stdout.  See the description of
527    ksba_reader_set_cb for details.  */
528 static int
529 reader_callback (void *cb_value, char *buffer, size_t count,  size_t *nread)
530 {
531   struct wrapper_context_s *ctx = cb_value;
532   size_t nleft = count;
533   int nfds;
534   struct timespec abstime;
535   struct timespec curtime;
536   struct timespec timeout;
537   int saved_errno;
538   fd_set fdset, read_fdset;
539   int ret;
540
541   /* FIXME: We might want to add some internal buffering because the
542      ksba code does not do any buffering for itself (because a ksba
543      reader may be detached from another stream to read other data and
544      the it would be cumbersome to get back already buffered
545      stuff).  */
546
547   if (!buffer && !count && !nread)
548     return -1; /* Rewind is not supported. */
549
550   /* If we ever encountered a read error don't allow to continue and
551      possible overwrite the last error cause.  Bail out also if the
552      file descriptor has been closed. */
553   if (ctx->fd_error || ctx->fd == -1)
554     {
555       *nread = 0;
556       return -1;
557     }
558
559   FD_ZERO (&fdset);
560   FD_SET (ctx->fd, &fdset);
561   nfds = ctx->fd + 1;
562
563   npth_clock_gettime (&abstime);
564   abstime.tv_sec += TIMERTICK_INTERVAL;
565
566   while (nleft > 0)
567     {
568       int n;
569       gpg_error_t err;
570
571       npth_clock_gettime (&curtime);
572       if (!(npth_timercmp (&curtime, &abstime, <)))
573         {
574           err = dirmngr_tick (ctx->ctrl);
575           if (err)
576             {
577               ctx->fd_error = err;
578               SAFE_CLOSE (ctx->fd);
579               return -1;
580             }
581           npth_clock_gettime (&abstime);
582           abstime.tv_sec += TIMERTICK_INTERVAL;
583         }
584       npth_timersub (&abstime, &curtime, &timeout);
585
586       read_fdset = fdset;
587       ret = npth_pselect (nfds, &read_fdset, NULL, NULL, &timeout, NULL);
588       saved_errno = errno;
589
590       if (ret == -1 && saved_errno != EINTR)
591         {
592           ctx->fd_error = gpg_error_from_errno (errno);
593           SAFE_CLOSE (ctx->fd);
594           return -1;
595         }
596       if (ret <= 0)
597         /* Timeout.  Will be handled when calculating the next timeout.  */
598         continue;
599
600       /* This should not block now that select returned with a file
601          descriptor.  So it shouldn't be necessary to use npth_read
602          (and it is slightly dangerous in the sense that a concurrent
603          thread might (accidentially?) change the status of ctx->fd
604          before we read.  FIXME: Set ctx->fd to nonblocking?  */
605       n = read (ctx->fd, buffer, nleft);
606       if (n < 0)
607         {
608           ctx->fd_error = gpg_error_from_errno (errno);
609           SAFE_CLOSE (ctx->fd);
610           return -1;
611         }
612       else if (!n)
613         {
614           if (nleft == count)
615             return -1; /* EOF. */
616           break;
617         }
618       nleft -= n;
619       buffer += n;
620       if (n > 0 && ctx->stamp != (time_t)(-1))
621         ctx->stamp = time (NULL);
622     }
623   *nread = count - nleft;
624
625   return 0;
626 }
627
628 /* Fork and exec the LDAP wrapper and return a new libksba reader
629    object at READER.  ARGV is a NULL terminated list of arguments for
630    the wrapper.  The function returns 0 on success or an error code.
631
632    Special hack to avoid passing a password through the command line
633    which is globally visible: If the first element of ARGV is "--pass"
634    it will be removed and instead the environment variable
635    DIRMNGR_LDAP_PASS will be set to the next value of ARGV.  On modern
636    OSes the environment is not visible to other users.  For those old
637    systems where it can't be avoided, we don't want to go into the
638    hassle of passing the password via stdin; it's just too complicated
639    and an LDAP password used for public directory lookups should not
640    be that confidential.  */
641 gpg_error_t
642 ldap_wrapper (ctrl_t ctrl, ksba_reader_t *reader, const char *argv[])
643 {
644   gpg_error_t err;
645   pid_t pid;
646   struct wrapper_context_s *ctx;
647   int i;
648   int j;
649   const char **arg_list;
650   const char *pgmname;
651   int outpipe[2], errpipe[2];
652
653   /* It would be too simple to connect stderr just to our logging
654      stream.  The problem is that if we are running multi-threaded
655      everything gets intermixed.  Clearly we don't want this.  So the
656      only viable solutions are either to have another thread
657      responsible for logging the messages or to add an option to the
658      wrapper module to do the logging on its own.  Given that we anyway
659      need a way to rip the child process and this is best done using a
660      general ripping thread, that thread can do the logging too. */
661
662   *reader = NULL;
663
664   /* Files: We need to prepare stdin and stdout.  We get stderr from
665      the function.  */
666   if (!opt.ldap_wrapper_program || !*opt.ldap_wrapper_program)
667     pgmname = gnupg_module_name (GNUPG_MODULE_NAME_DIRMNGR_LDAP);
668   else
669     pgmname = opt.ldap_wrapper_program;
670
671   /* Create command line argument array.  */
672   for (i = 0; argv[i]; i++)
673     ;
674   arg_list = xtrycalloc (i + 2, sizeof *arg_list);
675   if (!arg_list)
676     {
677       err = gpg_error_from_syserror ();
678       log_error (_("error allocating memory: %s\n"), strerror (errno));
679       return err;
680     }
681   for (i = j = 0; argv[i]; i++, j++)
682     if (!i && argv[i + 1] && !strcmp (*argv, "--pass"))
683       {
684         arg_list[j] = "--env-pass";
685         setenv ("DIRMNGR_LDAP_PASS", argv[1], 1);
686         i++;
687       }
688     else
689       arg_list[j] = (char*) argv[i];
690
691   ctx = xtrycalloc (1, sizeof *ctx);
692   if (!ctx)
693     {
694       err = gpg_error_from_syserror ();
695       log_error (_("error allocating memory: %s\n"), strerror (errno));
696       xfree (arg_list);
697       return err;
698     }
699
700   err = gnupg_create_inbound_pipe (outpipe);
701   if (!err)
702     {
703       err = gnupg_create_inbound_pipe (errpipe);
704       if (err)
705         {
706           close (outpipe[0]);
707           close (outpipe[1]);
708         }
709     }
710   if (err)
711     {
712       log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
713       xfree (arg_list);
714       xfree (ctx);
715       return err;
716     }
717
718   err = gnupg_spawn_process_fd (pgmname, arg_list,
719                                 -1, outpipe[1], errpipe[1], &pid);
720   xfree (arg_list);
721   close (outpipe[1]);
722   close (errpipe[1]);
723   if (err)
724     {
725       close (outpipe[0]);
726       close (errpipe[0]);
727       xfree (ctx);
728       return err;
729     }
730
731   ctx->pid = pid;
732   ctx->printable_pid = (int) pid;
733   ctx->fd = outpipe[0];
734   ctx->log_fd = errpipe[0];
735   ctx->ctrl = ctrl;
736   ctrl->refcount++;
737   ctx->stamp = time (NULL);
738
739   err = ksba_reader_new (reader);
740   if (!err)
741     err = ksba_reader_set_cb (*reader, reader_callback, ctx);
742   if (err)
743     {
744       log_error (_("error initializing reader object: %s\n"),
745                  gpg_strerror (err));
746       destroy_wrapper (ctx);
747       ksba_reader_release (*reader);
748       *reader = NULL;
749       return err;
750     }
751
752   /* Hook the context into our list of running wrappers.  */
753   ctx->reader = *reader;
754   ctx->next = wrapper_list;
755   wrapper_list = ctx;
756   if (opt.verbose)
757     log_info ("ldap wrapper %d started (reader %p)\n",
758               (int)ctx->pid, ctx->reader);
759
760   /* Need to wait for the first byte so we are able to detect an empty
761      output and not let the consumer see an EOF without further error
762      indications.  The CRL loading logic assumes that after return
763      from this function, a failed search (e.g. host not found ) is
764      indicated right away. */
765   {
766     unsigned char c;
767
768     err = read_buffer (*reader, &c, 1);
769     if (err)
770       {
771         ldap_wrapper_release_context (*reader);
772         ksba_reader_release (*reader);
773         *reader = NULL;
774         if (gpg_err_code (err) == GPG_ERR_EOF)
775           return gpg_error (GPG_ERR_NO_DATA);
776         else
777           return err;
778       }
779     ksba_reader_unread (*reader, &c, 1);
780   }
781
782   return 0;
783 }