Update option s2k-count to match the documentation.
[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 <pth.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
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   pth_event_t log_ev;
100   ctrl_t ctrl;  /* Connection data. */
101   int ready;    /* Internally used to mark to be removed contexts. */
102   ksba_reader_t reader; /* The ksba reader object or NULL. */
103   char *line;     /* Used to print the log lines (malloced). */
104   size_t linesize;/* Allocated size of LINE.  */
105   size_t linelen; /* Use size of LINE.  */
106   time_t stamp;   /* The last time we noticed ativity.  */
107 };
108
109
110
111 /* We keep a global list of spawed wrapper process.  A separate thread
112    makes use of this list to log error messages and to watch out for
113    finished processes. */
114 static struct wrapper_context_s *wrapper_list;
115
116 /* We need to know whether we are shutting down the process.  */
117 static int shutting_down;
118
119 /* Close the pth file descriptor FD and set it to -1.  */
120 #define SAFE_PTH_CLOSE(fd) \
121   do { int _fd = fd; if (_fd != -1) { pth_close (_fd); fd = -1;} } while (0)
122
123
124
125 \f
126 /* Read a fixed amount of data from READER into BUFFER.  */
127 static gpg_error_t
128 read_buffer (ksba_reader_t reader, unsigned char *buffer, size_t count)
129 {
130   gpg_error_t err;
131   size_t nread;
132
133   while (count)
134     {
135       err = ksba_reader_read (reader, buffer, count, &nread);
136       if (err)
137         return err;
138       buffer += nread;
139       count -= nread;
140     }
141   return 0;
142 }
143
144
145 /* Release the wrapper context and kill a running wrapper process. */
146 static void
147 destroy_wrapper (struct wrapper_context_s *ctx)
148 {
149   if (ctx->pid != (pid_t)(-1))
150     {
151       gnupg_kill_process (ctx->pid);
152       gnupg_release_process (ctx->pid);
153     }
154   ksba_reader_release (ctx->reader);
155   SAFE_PTH_CLOSE (ctx->fd);
156   SAFE_PTH_CLOSE (ctx->log_fd);
157   if (ctx->log_ev)
158     pth_event_free (ctx->log_ev, PTH_FREE_THIS);
159   xfree (ctx->line);
160   xfree (ctx);
161 }
162
163
164 /* Print the content of LINE to thye log stream but make sure to only
165    print complete lines.  Using NULL for LINE will flush any pending
166    output.  LINE may be modified by this fucntion. */
167 static void
168 print_log_line (struct wrapper_context_s *ctx, char *line)
169 {
170   char *s;
171   size_t n;
172
173   if (!line)
174     {
175       if (ctx->line && ctx->linelen)
176         {
177
178           log_info ("%s\n", ctx->line);
179           ctx->linelen = 0;
180         }
181       return;
182     }
183
184   while ((s = strchr (line, '\n')))
185     {
186       *s = 0;
187       if (ctx->line && ctx->linelen)
188         {
189           log_info ("%s", ctx->line);
190           ctx->linelen = 0;
191           log_printf ("%s\n", line);
192         }
193       else
194         log_info ("%s\n", line);
195       line = s + 1;
196     }
197   n = strlen (line);
198   if (n)
199     {
200       if (ctx->linelen + n + 1 >= ctx->linesize)
201         {
202           char *tmp;
203           size_t newsize;
204
205           newsize = ctx->linesize + ((n + 255) & ~255) + 1;
206           tmp = (ctx->line ? xtryrealloc (ctx->line, newsize)
207                            : xtrymalloc (newsize));
208           if (!tmp)
209             {
210               log_error (_("error printing log line: %s\n"), strerror (errno));
211               return;
212             }
213           ctx->line = tmp;
214           ctx->linesize = newsize;
215         }
216       memcpy (ctx->line + ctx->linelen, line, n);
217       ctx->linelen += n;
218       ctx->line[ctx->linelen] = 0;
219     }
220 }
221
222
223 /* Read data from the log stream.  Returns true if the log stream
224    indicated EOF or error.  */
225 static int
226 read_log_data (struct wrapper_context_s *ctx)
227 {
228   int n;
229   char line[256];
230
231   /* We must use the pth_read function for pipes, always.  */
232   do
233     n = pth_read (ctx->log_fd, line, sizeof line - 1);
234   while (n < 0 && errno == EINTR);
235
236   if (n <= 0) /* EOF or error. */
237     {
238       if (n < 0)
239         log_error (_("error reading log from ldap wrapper %d: %s\n"),
240                    ctx->pid, strerror (errno));
241       print_log_line (ctx, NULL);
242       SAFE_PTH_CLOSE (ctx->log_fd);
243       pth_event_free (ctx->log_ev, PTH_FREE_THIS);
244       ctx->log_ev = NULL;
245       return 1;
246     }
247
248   line[n] = 0;
249   print_log_line (ctx, line);
250   if (ctx->stamp != (time_t)(-1))
251     ctx->stamp = time (NULL);
252   return 0;
253 }
254
255
256 /* This function is run by a separate thread to maintain the list of
257    wrappers and to log error messages from these wrappers.  */
258 void *
259 ldap_wrapper_thread (void *dummy)
260 {
261   int nfds;
262   struct wrapper_context_s *ctx;
263   struct wrapper_context_s *ctx_prev;
264   time_t current_time;
265
266   (void)dummy;
267
268   for (;;)
269     {
270       pth_event_t timeout_ev;
271       int any_action = 0;
272       pth_time_t nexttick;
273
274       /* We timeout the pth_wait every 2 seconds.  To help with power
275          saving we syncronize the timeouts to the next full second.  */
276       nexttick = pth_timeout (2, 0);
277       if (nexttick.tv_usec > 10)  /* Use a 10 usec threshhold.  */
278         {
279           nexttick.tv_sec++;
280           nexttick.tv_usec = 0;
281         }
282       timeout_ev = pth_event (PTH_EVENT_TIME, nexttick);
283       if (! timeout_ev)
284         {
285           log_error (_("pth_event failed: %s\n"), strerror (errno));
286           pth_sleep (10);
287           continue;
288         }
289
290       for (ctx = wrapper_list; ctx; ctx = ctx->next)
291         {
292           if (ctx->log_fd != -1)
293             {
294               pth_event_isolate (ctx->log_ev);
295               pth_event_concat (timeout_ev, ctx->log_ev, NULL);
296             }
297         }
298
299       /* Note that the read FDs are actually handles.  Thus, we can
300          not use pth_select, but have to use pth_wait.  */
301       nfds = pth_wait (timeout_ev);
302       if (nfds < 0)
303         {
304           pth_event_free (timeout_ev, PTH_FREE_THIS);
305           log_error (_("pth_wait failed: %s\n"), strerror (errno));
306           pth_sleep (10);
307           continue;
308         }
309       if (pth_event_status (timeout_ev) == PTH_STATUS_OCCURRED)
310         nfds--;
311       pth_event_free (timeout_ev, PTH_FREE_THIS);
312
313       current_time = time (NULL);
314       if (current_time > INACTIVITY_TIMEOUT)
315         current_time -= INACTIVITY_TIMEOUT;
316
317       /* Note that there is no need to lock the list because we always
318          add entries at the head (with a pending event status) and
319          thus traversing the list will even work if we have a context
320          switch in waitpid (which should anyway only happen with Pth's
321          hard system call mapping).  */
322       for (ctx = wrapper_list; ctx; ctx = ctx->next)
323         {
324           /* Check whether there is any logging to be done. */
325           if (nfds && ctx->log_fd != -1
326               && pth_event_status (ctx->log_ev) == PTH_STATUS_OCCURRED)
327             {
328               if (read_log_data (ctx))
329                 any_action = 1;
330             }
331
332           /* Check whether the process is still running.  */
333           if (ctx->pid != (pid_t)(-1))
334             {
335               gpg_error_t err;
336               int status;
337
338               err = gnupg_wait_process ("[dirmngr_ldap]", ctx->pid, 0,
339                                         &status);
340               if (!err)
341                 {
342                   log_info (_("ldap wrapper %d ready"), (int)ctx->pid);
343                   ctx->ready = 1;
344                   gnupg_release_process (ctx->pid);
345                   ctx->pid = (pid_t)(-1);
346                   any_action = 1;
347                 }
348               else if (gpg_err_code (err) == GPG_ERR_GENERAL)
349                 {
350                   if (status == 10)
351                     log_info (_("ldap wrapper %d ready: timeout\n"),
352                               (int)ctx->pid);
353                   else
354                     log_info (_("ldap wrapper %d ready: exitcode=%d\n"),
355                               (int)ctx->pid, status);
356                   ctx->ready = 1;
357                   gnupg_release_process (ctx->pid);
358                   ctx->pid = (pid_t)(-1);
359                   any_action = 1;
360                 }
361               else if (gpg_err_code (err) != GPG_ERR_TIMEOUT)
362                 {
363                   log_error (_("waiting for ldap wrapper %d failed: %s\n"),
364                              (int)ctx->pid, gpg_strerror (err));
365                   any_action = 1;
366                 }
367             }
368
369           /* Check whether we should terminate the process. */
370           if (ctx->pid != (pid_t)(-1)
371               && ctx->stamp != (time_t)(-1) && ctx->stamp < current_time)
372             {
373               gnupg_kill_process (ctx->pid);
374               ctx->stamp = (time_t)(-1);
375               log_info (_("ldap wrapper %d stalled - killing\n"),
376                         (int)ctx->pid);
377               /* We need to close the log fd because the cleanup loop
378                  waits for it.  */
379               SAFE_PTH_CLOSE (ctx->log_fd);
380               any_action = 1;
381             }
382         }
383
384       /* If something has been printed to the log file or we got an
385          EOF from a wrapper, we now print the list of active
386          wrappers.  */
387       if (any_action && DBG_LOOKUP)
388         {
389           log_info ("ldap worker stati:\n");
390           for (ctx = wrapper_list; ctx; ctx = ctx->next)
391             log_info ("  c=%p pid=%d/%d rdr=%p ctrl=%p/%d la=%lu rdy=%d\n",
392                       ctx,
393                       (int)ctx->pid, (int)ctx->printable_pid,
394                       ctx->reader,
395                       ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0,
396                       (unsigned long)ctx->stamp, ctx->ready);
397         }
398
399
400       /* Use a separate loop to check whether ready marked wrappers
401          may be removed.  We may only do so if the ksba reader object
402          is not anymore in use or we are in shutdown state.  */
403      again:
404       for (ctx_prev=NULL, ctx=wrapper_list; ctx; ctx_prev=ctx, ctx=ctx->next)
405         if (ctx->ready
406             && ((ctx->log_fd == -1 && !ctx->reader) || shutting_down))
407           {
408             if (ctx_prev)
409               ctx_prev->next = ctx->next;
410             else
411               wrapper_list = ctx->next;
412             destroy_wrapper (ctx);
413             /* We need to restart because destroy_wrapper might have
414                done a context switch. */
415             goto again;
416           }
417     }
418   /*NOTREACHED*/
419   return NULL; /* Make the compiler happy.  */
420 }
421
422
423
424 /* Start the reaper thread for the ldap wrapper.  */
425 void
426 ldap_wrapper_launch_thread (void)
427 {
428   static int done;
429   pth_attr_t tattr;
430
431   if (done)
432     return;
433   done = 1;
434
435   tattr = pth_attr_new();
436   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
437   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
438   pth_attr_set (tattr, PTH_ATTR_NAME, "ldap-reaper");
439
440   if (!pth_spawn (tattr, ldap_wrapper_thread, NULL))
441     {
442       log_error (_("error spawning ldap wrapper reaper thread: %s\n"),
443                  strerror (errno) );
444       dirmngr_exit (1);
445     }
446   pth_attr_destroy (tattr);
447 }
448
449
450
451
452
453 /* Wait until all ldap wrappers have terminated.  We assume that the
454    kill has already been sent to all of them.  */
455 void
456 ldap_wrapper_wait_connections ()
457 {
458   shutting_down = 1;
459   while (wrapper_list)
460     pth_yield (NULL);
461 }
462
463
464 /* This function is to be used to release a context associated with the
465    given reader object. */
466 void
467 ldap_wrapper_release_context (ksba_reader_t reader)
468 {
469   struct wrapper_context_s *ctx;
470
471   if (!reader )
472     return;
473
474   for (ctx=wrapper_list; ctx; ctx=ctx->next)
475     if (ctx->reader == reader)
476       {
477         if (DBG_LOOKUP)
478           log_info ("releasing ldap worker c=%p pid=%d/%d rdr=%p ctrl=%p/%d\n",
479                     ctx,
480                     (int)ctx->pid, (int)ctx->printable_pid,
481                     ctx->reader,
482                     ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0);
483
484         ctx->reader = NULL;
485         SAFE_PTH_CLOSE (ctx->fd);
486         if (ctx->ctrl)
487           {
488             ctx->ctrl->refcount--;
489             ctx->ctrl = NULL;
490           }
491         if (ctx->fd_error)
492           log_info (_("reading from ldap wrapper %d failed: %s\n"),
493                     ctx->printable_pid, gpg_strerror (ctx->fd_error));
494         break;
495       }
496 }
497
498 /* Cleanup all resources held by the connection associated with
499    CTRL.  This is used after a cancel to kill running wrappers.  */
500 void
501 ldap_wrapper_connection_cleanup (ctrl_t ctrl)
502 {
503   struct wrapper_context_s *ctx;
504
505   for (ctx=wrapper_list; ctx; ctx=ctx->next)
506     if (ctx->ctrl && ctx->ctrl == ctrl)
507       {
508         ctx->ctrl->refcount--;
509         ctx->ctrl = NULL;
510         if (ctx->pid != (pid_t)(-1))
511           gnupg_kill_process (ctx->pid);
512         if (ctx->fd_error)
513           log_info (_("reading from ldap wrapper %d failed: %s\n"),
514                     ctx->printable_pid, gpg_strerror (ctx->fd_error));
515       }
516 }
517
518 /* This is the callback used by the ldap wrapper to feed the ksba
519    reader with the wrappers stdout.  See the description of
520    ksba_reader_set_cb for details.  */
521 static int
522 reader_callback (void *cb_value, char *buffer, size_t count,  size_t *nread)
523 {
524   struct wrapper_context_s *ctx = cb_value;
525   size_t nleft = count;
526
527   /* FIXME: We might want to add some internal buffering because the
528      ksba code does not do any buffering for itself (because a ksba
529      reader may be detached from another stream to read other data and
530      the it would be cumbersome to get back already buffered
531      stuff).  */
532
533   if (!buffer && !count && !nread)
534     return -1; /* Rewind is not supported. */
535
536   /* If we ever encountered a read error don't allow to continue and
537      possible overwrite the last error cause.  Bail out also if the
538      file descriptor has been closed. */
539   if (ctx->fd_error || ctx->fd == -1)
540     {
541       *nread = 0;
542       return -1;
543     }
544
545   while (nleft > 0)
546     {
547       int n;
548       pth_event_t evt;
549       gpg_error_t err;
550
551       evt = pth_event (PTH_EVENT_TIME, pth_timeout (1, 0));
552       n = pth_read_ev (ctx->fd, buffer, nleft, evt);
553       if (n < 0 && evt && pth_event_occurred (evt))
554         {
555           n = 0;
556           err = dirmngr_tick (ctx->ctrl);
557           if (err)
558             {
559               ctx->fd_error = err;
560               SAFE_PTH_CLOSE (ctx->fd);
561               if (evt)
562                 pth_event_free (evt, PTH_FREE_THIS);
563               return -1;
564             }
565
566         }
567       else if (n < 0)
568         {
569           ctx->fd_error = gpg_error_from_errno (errno);
570           SAFE_PTH_CLOSE (ctx->fd);
571           if (evt)
572             pth_event_free (evt, PTH_FREE_THIS);
573           return -1;
574         }
575       else if (!n)
576         {
577           if (nleft == count)
578             {
579               if (evt)
580                 pth_event_free (evt, PTH_FREE_THIS);
581               return -1; /* EOF. */
582             }
583           break;
584         }
585       nleft -= n;
586       buffer += n;
587       if (evt)
588         pth_event_free (evt, PTH_FREE_THIS);
589       if (n > 0 && ctx->stamp != (time_t)(-1))
590         ctx->stamp = time (NULL);
591     }
592   *nread = count - nleft;
593
594   return 0;
595
596 }
597
598 /* Fork and exec the LDAP wrapper and returns a new libksba reader
599    object at READER.  ARGV is a NULL terminated list of arguments for
600    the wrapper.  The function returns 0 on success or an error code.
601
602    Special hack to avoid passing a password through the command line
603    which is globally visible: If the first element of ARGV is "--pass"
604    it will be removed and instead the environment variable
605    DIRMNGR_LDAP_PASS will be set to the next value of ARGV.  On modern
606    OSes the environment is not visible to other users.  For those old
607    systems where it can't be avoided, we don't want to go into the
608    hassle of passing the password via stdin; it's just too complicated
609    and an LDAP password used for public directory lookups should not
610    be that confidential.  */
611 gpg_error_t
612 ldap_wrapper (ctrl_t ctrl, ksba_reader_t *reader, const char *argv[])
613 {
614   gpg_error_t err;
615   pid_t pid;
616   struct wrapper_context_s *ctx;
617   int i;
618   int j;
619   const char **arg_list;
620   const char *pgmname;
621   int outpipe[2], errpipe[2];
622
623   /* It would be too simple to connect stderr just to our logging
624      stream.  The problem is that if we are running multi-threaded
625      everything gets intermixed.  Clearly we don't want this.  So the
626      only viable solutions are either to have another thread
627      responsible for logging the messages or to add an option to the
628      wrapper module to do the logging on its own.  Given that we anyway
629      need a way to rip the child process and this is best done using a
630      general ripping thread, that thread can do the logging too. */
631
632   *reader = NULL;
633
634   /* Files: We need to prepare stdin and stdout.  We get stderr from
635      the function.  */
636   if (!opt.ldap_wrapper_program || !*opt.ldap_wrapper_program)
637     pgmname = gnupg_module_name (GNUPG_MODULE_NAME_DIRMNGR_LDAP);
638   else
639     pgmname = opt.ldap_wrapper_program;
640
641   /* Create command line argument array.  */
642   for (i = 0; argv[i]; i++)
643     ;
644   arg_list = xtrycalloc (i + 2, sizeof *arg_list);
645   if (!arg_list)
646     {
647       err = gpg_error_from_syserror ();
648       log_error (_("error allocating memory: %s\n"), strerror (errno));
649       return err;
650     }
651   for (i = j = 0; argv[i]; i++, j++)
652     if (!i && argv[i + 1] && !strcmp (*argv, "--pass"))
653       {
654         arg_list[j] = "--env-pass";
655         setenv ("DIRMNGR_LDAP_PASS", argv[1], 1);
656         i++;
657       }
658     else
659       arg_list[j] = (char*) argv[i];
660
661   ctx = xtrycalloc (1, sizeof *ctx);
662   if (!ctx)
663     {
664       err = gpg_error_from_syserror ();
665       log_error (_("error allocating memory: %s\n"), strerror (errno));
666       xfree (arg_list);
667       return err;
668     }
669
670   err = gnupg_create_inbound_pipe (outpipe);
671   if (!err)
672     {
673       err = gnupg_create_inbound_pipe (errpipe);
674       if (err)
675         {
676           close (outpipe[0]);
677           close (outpipe[1]);
678         }
679     }
680   if (err)
681     {
682       log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
683       xfree (arg_list);
684       xfree (ctx);
685       return err;
686     }
687
688   err = gnupg_spawn_process_fd (pgmname, arg_list,
689                                 -1, outpipe[1], errpipe[1], &pid);
690   xfree (arg_list);
691   close (outpipe[1]);
692   close (errpipe[1]);
693   if (err)
694     {
695       close (outpipe[0]);
696       close (errpipe[0]);
697       xfree (ctx);
698       return err;
699     }
700
701   ctx->pid = pid;
702   ctx->printable_pid = (int) pid;
703   ctx->fd = outpipe[0];
704   ctx->log_fd = errpipe[0];
705   ctx->log_ev = pth_event (PTH_EVENT_FD | PTH_UNTIL_FD_READABLE, ctx->log_fd);
706   if (! ctx->log_ev)
707     {
708       xfree (ctx);
709       return gpg_error_from_syserror ();
710     }
711   ctx->ctrl = ctrl;
712   ctrl->refcount++;
713   ctx->stamp = time (NULL);
714
715   err = ksba_reader_new (reader);
716   if (!err)
717     err = ksba_reader_set_cb (*reader, reader_callback, ctx);
718   if (err)
719     {
720       log_error (_("error initializing reader object: %s\n"),
721                  gpg_strerror (err));
722       destroy_wrapper (ctx);
723       ksba_reader_release (*reader);
724       *reader = NULL;
725       return err;
726     }
727
728   /* Hook the context into our list of running wrappers.  */
729   ctx->reader = *reader;
730   ctx->next = wrapper_list;
731   wrapper_list = ctx;
732   if (opt.verbose)
733     log_info ("ldap wrapper %d started (reader %p)\n",
734               (int)ctx->pid, ctx->reader);
735
736   /* Need to wait for the first byte so we are able to detect an empty
737      output and not let the consumer see an EOF without further error
738      indications.  The CRL loading logic assumes that after return
739      from this function, a failed search (e.g. host not found ) is
740      indicated right away. */
741   {
742     unsigned char c;
743
744     err = read_buffer (*reader, &c, 1);
745     if (err)
746       {
747         ldap_wrapper_release_context (*reader);
748         ksba_reader_release (*reader);
749         *reader = NULL;
750         if (gpg_err_code (err) == GPG_ERR_EOF)
751           return gpg_error (GPG_ERR_NO_DATA);
752         else
753           return err;
754       }
755     ksba_reader_unread (*reader, &c, 1);
756   }
757
758   return 0;
759 }