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