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