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