Merged Dirmngr with GnuPG.
[gnupg.git] / dirmngr / ldap.c
1 /* ldap.c - LDAP access
2  * Copyright (C) 2002 Klarälvdalens Datakonsult AB
3  * Copyright (C) 2003, 2004, 2005, 2007, 2008, 2010 g10 Code GmbH
4  *
5  * This file is part of DirMngr.
6  *
7  * DirMngr 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 2 of the License, or
10  * (at your option) any later version.
11  *
12  * DirMngr 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, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <unistd.h>
29 #include <fcntl.h>
30 #include <time.h>
31 #include <pth.h>
32
33 #include "dirmngr.h"
34 #include "exechelp.h"
35 #include "crlfetch.h"
36 #include "ldapserver.h"
37 #include "misc.h"
38
39 #ifdef HAVE_W32_SYSTEM
40 #define setenv(a,b,c) SetEnvironmentVariable ((a),(b))
41 #else
42 #define pth_close(fd) close(fd)
43 #endif
44
45
46 /* In case sysconf does not return a value we need to have a limit. */
47 #ifdef _POSIX_OPEN_MAX
48 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
49 #else
50 #define MAX_OPEN_FDS 20
51 #endif
52
53 #define INACTIVITY_TIMEOUT (opt.ldaptimeout + 60*5)  /* seconds */
54
55 #define UNENCODED_URL_CHARS "abcdefghijklmnopqrstuvwxyz"   \
56                             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"   \
57                             "01234567890"                  \
58                             "$-_.+!*'(),"
59 #define USERCERTIFICATE "userCertificate"
60 #define CACERTIFICATE   "caCertificate"
61 #define X509CACERT      "x509caCert"
62 #define USERSMIMECERTIFICATE "userSMIMECertificate"
63
64
65 /* Definition for the context of the cert fetch functions. */
66 struct cert_fetch_context_s
67 {
68   ksba_reader_t reader;  /* The reader used (shallow copy). */
69   unsigned char *tmpbuf; /* Helper buffer.  */
70   size_t tmpbufsize;     /* Allocated size of tmpbuf.  */
71   int truncated;         /* Flag to indicate a truncated output.  */
72 };
73
74
75 /* To keep track of the LDAP wrapper state we use this structure.  */
76 struct wrapper_context_s
77 {
78   struct wrapper_context_s *next;
79
80   pid_t pid;    /* The pid of the wrapper process. */
81   int printable_pid; /* Helper to print diagnostics after the process has
82                         been cleaned up. */
83   int fd;       /* Connected with stdout of the ldap wrapper.  */
84   gpg_error_t fd_error; /* Set to the gpg_error of the last read error
85                            if any.  */
86   int log_fd;   /* Connected with stderr of the ldap wrapper.  */
87   pth_event_t log_ev;
88   ctrl_t ctrl;  /* Connection data. */
89   int ready;    /* Internally used to mark to be removed contexts. */
90   ksba_reader_t reader; /* The ksba reader object or NULL. */
91   char *line;     /* Used to print the log lines (malloced). */
92   size_t linesize;/* Allocated size of LINE.  */
93   size_t linelen; /* Use size of LINE.  */
94   time_t stamp;   /* The last time we noticed ativity.  */
95 };
96
97
98
99
100
101 /* We keep a global list of spawed wrapper process.  A separate thread
102    makes use of this list to log error messages and to watch out for
103    finished processes. */
104 static struct wrapper_context_s *wrapper_list;
105
106 /* We need to know whether we are shutting down the process.  */
107 static int shutting_down;
108
109 /* Close the pth file descriptor FD and set it to -1.  */
110 #define SAFE_PTH_CLOSE(fd) \
111   do { int _fd = fd; if (_fd != -1) { pth_close (_fd); fd = -1;} } while (0)
112
113
114 /* Prototypes.  */
115 static gpg_error_t read_buffer (ksba_reader_t reader,
116                                 unsigned char *buffer, size_t count);
117
118
119
120 \f
121 /* Add HOST and PORT to our list of LDAP servers.  Fixme: We should
122    better use an extra list of servers. */
123 static void
124 add_server_to_servers (const char *host, int port)
125 {
126   ldap_server_t server;
127   ldap_server_t last = NULL;
128   const char *s;
129
130   if (!port)
131     port = 389;
132
133   for (server=opt.ldapservers; server; server = server->next)
134     {
135       if (!strcmp (server->host, host) && server->port == port)
136           return; /* already in list... */
137       last = server;
138     }
139
140   /* We assume that the host names are all supplied by our
141      configuration files and thus are sane.  To keep this assumption
142      we must reject all invalid host names. */
143   for (s=host; *s; s++)
144     if (!strchr ("abcdefghijklmnopqrstuvwxyz"
145                  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
146                  "01234567890.-", *s))
147       {
148         log_error (_("invalid char 0x%02x in host name - not added\n"), *s);
149         return;
150       }
151
152   log_info (_("adding `%s:%d' to the ldap server list\n"), host, port);
153   server = xtrycalloc (1, sizeof *s);
154   if (!server)
155     log_error (_("malloc failed: %s\n"), strerror (errno));
156   else
157     {
158       server->host = xstrdup (host);
159       server->port = port;
160       if (last)
161         last->next = server;
162       else
163         opt.ldapservers = server;
164     }
165 }
166
167
168 /* Release the wrapper context and kill a running wrapper process. */
169 static void
170 destroy_wrapper (struct wrapper_context_s *ctx) 
171 {
172   if (ctx->pid != (pid_t)(-1))
173     {
174       gnupg_kill_process (ctx->pid);
175       gnupg_release_process (ctx->pid);
176     }
177   ksba_reader_release (ctx->reader);
178   SAFE_PTH_CLOSE (ctx->fd);
179   SAFE_PTH_CLOSE (ctx->log_fd);
180   if (ctx->log_ev)
181     pth_event_free (ctx->log_ev, PTH_FREE_THIS);
182   xfree (ctx->line);
183   xfree (ctx);
184 }
185
186
187 /* Print the content of LINE to thye log stream but make sure to only
188    print complete lines.  Using NULL for LINE will flush any pending
189    output.  LINE may be modified by this fucntion. */
190 static void
191 print_log_line (struct wrapper_context_s *ctx, char *line)
192 {
193   char *s;
194   size_t n;
195
196   if (!line)
197     {
198       if (ctx->line && ctx->linelen)
199         {
200
201           log_info ("%s\n", ctx->line); 
202           ctx->linelen = 0;
203         }
204       return;
205     }
206   
207   while ((s = strchr (line, '\n')))
208     {
209       *s = 0;
210       if (ctx->line && ctx->linelen)
211         {
212           log_info ("%s", ctx->line); 
213           ctx->linelen = 0;
214           log_printf ("%s\n", line);
215         }
216       else
217         log_info ("%s\n", line);
218       line = s + 1;
219     }
220   n = strlen (line);
221   if (n)
222     {
223       if (ctx->linelen + n + 1 >= ctx->linesize)
224         {
225           char *tmp;
226           size_t newsize;
227
228           newsize = ctx->linesize + ((n + 255) & ~255) + 1;
229           tmp = (ctx->line ? xtryrealloc (ctx->line, newsize)
230                            : xtrymalloc (newsize));
231           if (!tmp)
232             {
233               log_error (_("error printing log line: %s\n"), strerror (errno));
234               return;
235             }
236           ctx->line = tmp;
237           ctx->linesize = newsize;
238         }
239       memcpy (ctx->line + ctx->linelen, line, n);
240       ctx->linelen += n;
241       ctx->line[ctx->linelen] = 0;
242     }
243 }
244
245
246 /* Read data from the log stream.  Returns true if the log stream
247    indicated EOF or error.  */
248 static int
249 read_log_data (struct wrapper_context_s *ctx)
250 {
251   int n;
252   char line[256];
253
254   /* We must use the pth_read function for pipes, always.  */
255   do 
256     n = pth_read (ctx->log_fd, line, sizeof line - 1);
257   while (n < 0 && errno == EINTR);
258
259   if (n <= 0) /* EOF or error. */
260     {
261       if (n < 0)
262         log_error (_("error reading log from ldap wrapper %d: %s\n"),
263                    ctx->pid, strerror (errno));
264       print_log_line (ctx, NULL);
265       SAFE_PTH_CLOSE (ctx->log_fd);
266       pth_event_free (ctx->log_ev, PTH_FREE_THIS);
267       ctx->log_ev = NULL;
268       return 1;
269     }
270
271   line[n] = 0;
272   print_log_line (ctx, line);
273   if (ctx->stamp != (time_t)(-1))
274     ctx->stamp = time (NULL);
275   return 0;
276 }
277
278
279 /* This function is run by a separate thread to maintain the list of
280    wrappers and to log error messages from these wrappers. */
281 void *
282 ldap_wrapper_thread (void *dummy)
283 {
284   int nfds;
285   struct wrapper_context_s *ctx;
286   struct wrapper_context_s *ctx_prev;
287   time_t current_time;
288
289   (void)dummy;
290
291   for (;;)
292     {
293       pth_event_t timeout_ev;
294       int any_action = 0;
295
296       timeout_ev = pth_event (PTH_EVENT_TIME, pth_timeout (1, 0));
297       if (! timeout_ev)
298         {
299           log_error (_("pth_event failed: %s\n"), strerror (errno));
300           pth_sleep (10);
301           continue;
302         }
303
304       for (ctx = wrapper_list; ctx; ctx = ctx->next)
305         {
306           if (ctx->log_fd != -1)
307             {
308               pth_event_isolate (ctx->log_ev);
309               pth_event_concat (timeout_ev, ctx->log_ev, NULL);
310             }
311         }
312
313       /* Note that the read FDs are actually handles.  Thus, we can
314          not use pth_select, but have to use pth_wait.  */
315       nfds = pth_wait (timeout_ev);
316       if (nfds < 0)
317         {
318           pth_event_free (timeout_ev, PTH_FREE_THIS);
319           log_error (_("pth_wait failed: %s\n"), strerror (errno));
320           pth_sleep (10);
321           continue;
322         }
323       if (pth_event_status (timeout_ev) == PTH_STATUS_OCCURRED)
324         nfds--;
325       pth_event_free (timeout_ev, PTH_FREE_THIS);
326
327       current_time = time (NULL);
328       if (current_time > INACTIVITY_TIMEOUT)
329         current_time -= INACTIVITY_TIMEOUT;
330
331       /* Note that there is no need to lock the list because we always
332          add entries at the head (with a pending event status) and
333          thus traversing the list will even work if we have a context
334          switch in waitpid (which should anyway only happen with Pth's
335          hard system call mapping).  */
336       for (ctx = wrapper_list; ctx; ctx = ctx->next)
337         {
338           /* Check whether there is any logging to be done. */
339           if (nfds && ctx->log_fd != -1
340               && pth_event_status (ctx->log_ev) == PTH_STATUS_OCCURRED)
341             {
342               if (read_log_data (ctx))
343                 any_action = 1;
344             }
345
346           /* Check whether the process is still running.  */
347           if (ctx->pid != (pid_t)(-1))
348             {
349               gpg_error_t err;
350               int status;
351               
352               err = gnupg_wait_process ("[dirmngr_ldap]", ctx->pid, 0,
353                                         &status);
354               if (!err)
355                 {
356                   log_info (_("ldap wrapper %d ready"), (int)ctx->pid);
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_GENERAL)
363                 {
364                   if (status == 10)
365                     log_info (_("ldap wrapper %d ready: timeout\n"),
366                               (int)ctx->pid);
367                   else
368                     log_info (_("ldap wrapper %d ready: exitcode=%d\n"),
369                               (int)ctx->pid, status);
370                   ctx->ready = 1;
371                   gnupg_release_process (ctx->pid);
372                   ctx->pid = (pid_t)(-1);
373                   any_action = 1;
374                 }
375               else if (gpg_err_code (err) != GPG_ERR_TIMEOUT)
376                 {
377                   log_error (_("waiting for ldap wrapper %d failed: %s\n"),
378                              (int)ctx->pid, gpg_strerror (err));
379                   any_action = 1;
380                 }
381             }
382
383           /* Check whether we should terminate the process. */
384           if (ctx->pid != (pid_t)(-1)
385               && ctx->stamp != (time_t)(-1) && ctx->stamp < current_time)
386             {
387               gnupg_kill_process (ctx->pid);
388               ctx->stamp = (time_t)(-1);
389               log_info (_("ldap wrapper %d stalled - killing\n"),
390                         (int)ctx->pid);
391               /* We need to close the log fd because the cleanup loop
392                  waits for it.  */
393               SAFE_PTH_CLOSE (ctx->log_fd);
394               any_action = 1;
395             }
396         }
397
398       /* If something has been printed to the log file or we got an
399          EOF from a wrapper, we now print the list of active
400          wrappers.  */
401       if (any_action && DBG_LOOKUP) 
402         {
403           log_info ("ldap worker stati:\n");
404           for (ctx = wrapper_list; ctx; ctx = ctx->next)
405             log_info ("  c=%p pid=%d/%d rdr=%p ctrl=%p/%d la=%lu rdy=%d\n",
406                       ctx, 
407                       (int)ctx->pid, (int)ctx->printable_pid,
408                       ctx->reader,
409                       ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0, 
410                       (unsigned long)ctx->stamp, ctx->ready);
411         }
412
413
414       /* Use a separate loop to check whether ready marked wrappers
415          may be removed.  We may only do so if the ksba reader object
416          is not anymore in use or we are in shutdown state.  */
417      again:
418       for (ctx_prev=NULL, ctx=wrapper_list; ctx; ctx_prev=ctx, ctx=ctx->next)
419         if (ctx->ready 
420             && ((ctx->log_fd == -1 && !ctx->reader) || shutting_down))
421           {
422             if (ctx_prev)
423               ctx_prev->next = ctx->next;
424             else
425               wrapper_list = ctx->next;
426             destroy_wrapper (ctx);
427             /* We need to restart because destroy_wrapper might have
428                done a context switch. */
429             goto again;
430           }
431     }
432   /*NOTREACHED*/
433   return NULL; /* Make the compiler happy.  */
434 }
435
436
437
438 /* Wait until all ldap wrappers have terminated.  We assume that the
439    kill has already been sent to all of them.  */
440 void
441 ldap_wrapper_wait_connections ()
442 {
443   shutting_down = 1;
444   while (wrapper_list)
445     pth_yield (NULL);
446 }
447
448
449 /* This function is to be used to release a context associated with the
450    given reader object. */
451 void
452 ldap_wrapper_release_context (ksba_reader_t reader)
453 {
454   struct wrapper_context_s *ctx;
455
456   if (!reader )
457     return;
458     
459   for (ctx=wrapper_list; ctx; ctx=ctx->next)
460     if (ctx->reader == reader)
461       {
462         if (DBG_LOOKUP)
463           log_info ("releasing ldap worker c=%p pid=%d/%d rdr=%p ctrl=%p/%d\n",
464                     ctx, 
465                     (int)ctx->pid, (int)ctx->printable_pid,
466                     ctx->reader,
467                     ctx->ctrl, ctx->ctrl? ctx->ctrl->refcount:0);
468
469         ctx->reader = NULL;
470         SAFE_PTH_CLOSE (ctx->fd);
471         if (ctx->ctrl)
472           {
473             ctx->ctrl->refcount--;
474             ctx->ctrl = NULL;
475           }
476         if (ctx->fd_error)
477           log_info (_("reading from ldap wrapper %d failed: %s\n"),
478                     ctx->printable_pid, gpg_strerror (ctx->fd_error));
479         break;
480       }
481 }
482
483 /* Cleanup all resources held by the connection associated with
484    CTRL.  This is used after a cancel to kill running wrappers.  */
485 void
486 ldap_wrapper_connection_cleanup (ctrl_t ctrl)
487 {
488   struct wrapper_context_s *ctx;
489
490   for (ctx=wrapper_list; ctx; ctx=ctx->next)
491     if (ctx->ctrl && ctx->ctrl == ctrl)
492       {
493         ctx->ctrl->refcount--;
494         ctx->ctrl = NULL;
495         if (ctx->pid != (pid_t)(-1))
496           gnupg_kill_process (ctx->pid);
497         if (ctx->fd_error)
498           log_info (_("reading from ldap wrapper %d failed: %s\n"),
499                     ctx->printable_pid, gpg_strerror (ctx->fd_error));
500       }
501 }
502
503 /* This is the callback used by the ldap wrapper to feed the ksba
504    reader with the wrappers stdout.  See the description of
505    ksba_reader_set_cb for details.  */
506 static int 
507 reader_callback (void *cb_value, char *buffer, size_t count,  size_t *nread)
508 {
509   struct wrapper_context_s *ctx = cb_value;
510   size_t nleft = count;
511
512   /* FIXME: We might want to add some internal buffering because the
513      ksba code does not do any buffering for itself (because a ksba
514      reader may be detached from another stream to read other data and
515      the it would be cumbersome to get back already buffered
516      stuff).  */
517
518   if (!buffer && !count && !nread)
519     return -1; /* Rewind is not supported. */
520
521   /* If we ever encountered a read error don't allow to continue and
522      possible overwrite the last error cause.  Bail out also if the
523      file descriptor has been closed. */
524   if (ctx->fd_error || ctx->fd == -1)
525     {
526       *nread = 0;
527       return -1;
528     }
529
530   while (nleft > 0)
531     {
532       int n;
533       pth_event_t evt;
534       gpg_error_t err;
535
536       evt = pth_event (PTH_EVENT_TIME, pth_timeout (1, 0));
537       n = pth_read_ev (ctx->fd, buffer, nleft, evt);
538       if (n < 0 && evt && pth_event_occurred (evt))
539         {
540           n = 0;
541           err = dirmngr_tick (ctx->ctrl);
542           if (err)
543             {
544               ctx->fd_error = err;
545               SAFE_PTH_CLOSE (ctx->fd);
546               if (evt)
547                 pth_event_free (evt, PTH_FREE_THIS);
548               return -1;
549             }
550
551         }
552       else if (n < 0)
553         {
554           ctx->fd_error = gpg_error_from_errno (errno);
555           SAFE_PTH_CLOSE (ctx->fd);
556           if (evt)
557             pth_event_free (evt, PTH_FREE_THIS);
558           return -1;
559         }
560       else if (!n)
561         {
562           if (nleft == count)
563             {
564               if (evt)
565                 pth_event_free (evt, PTH_FREE_THIS);
566               return -1; /* EOF. */
567             }
568           break; 
569         }
570       nleft -= n;
571       buffer += n;
572       if (evt)
573         pth_event_free (evt, PTH_FREE_THIS);
574       if (n > 0 && ctx->stamp != (time_t)(-1))
575         ctx->stamp = time (NULL);
576     }
577   *nread = count - nleft;
578
579   return 0;
580
581 }
582
583 /* Fork and exec the LDAP wrapper and returns a new libksba reader
584    object at READER.  ARGV is a NULL terminated list of arguments for
585    the wrapper.  The function returns 0 on success or an error code.
586
587    We can't use LDAP directly for these reasons:
588
589    1. On some systems the LDAP library uses (indirectly) pthreads and
590       that is not compatible with PTh.
591   
592    2. It is huge library in particular if TLS comes into play.  So
593       problems with unfreed memory might turn up and we don't want
594       this in a long running daemon.
595
596    3. There is no easy way for timeouts. In particular the timeout
597       value does not work for DNS lookups (well, this is usual) and it
598       seems not to work while loading a large attribute like a
599       CRL. Having a separate process allows us to either tell the
600       process to commit suicide or have our own housekepping function
601       kill it after some time.  The latter also allows proper
602       cancellation of a query at any point of time.
603       
604    4. Given that we are going out to the network and usually get back
605       a long response, the fork/exec overhead is acceptable.
606
607    Special hack to avoid passing a password through the command line
608    which is globally visible: If the first element of ARGV is "--pass"
609    it will be removed and instead the environment variable
610    DIRMNGR_LDAP_PASS will be set to the next value of ARGV.  On modern
611    OSes the environment is not visible to other users.  For those old
612    systems where it can't be avoided, we don't want to go into the
613    hassle of passing the password via stdin; it's just too complicated
614    and an LDAP password used for public directory lookups should not
615    be that confidential.  */
616 static gpg_error_t
617 ldap_wrapper (ctrl_t ctrl, ksba_reader_t *reader, const char *argv[])
618 {
619   gpg_error_t err;
620   pid_t pid;
621   struct wrapper_context_s *ctx;
622   int i;
623   int j;
624   const char **arg_list;
625   const char *pgmname;
626   int outpipe[2], errpipe[2];
627
628   /* It would be too simple to connect stderr just to our logging
629      stream.  The problem is that if we are running multi-threaded
630      everything gets intermixed.  Clearly we don't want this.  So the
631      only viable solutions are either to have another thread
632      responsible for logging the messages or to add an option to the
633      wrapper module to do the logging on its own.  Given that we anyway
634      need a way to rip the child process and this is best done using a
635      general ripping thread, that thread can do the logging too. */
636
637   *reader = NULL;
638
639   /* Files: We need to prepare stdin and stdout.  We get stderr from
640      the function.  */
641   if (!opt.ldap_wrapper_program || !*opt.ldap_wrapper_program)
642     pgmname = gnupg_module_name (GNUPG_MODULE_NAME_DIRMNGR_LDAP);
643   else
644     pgmname = opt.ldap_wrapper_program;
645
646   /* Create command line argument array.  */
647   for (i = 0; argv[i]; i++)
648     ;
649   arg_list = xtrycalloc (i + 2, sizeof *arg_list);
650   if (!arg_list)
651     {
652       err = gpg_error_from_syserror ();
653       log_error (_("error allocating memory: %s\n"), strerror (errno));
654       return err;
655     }
656   for (i = j = 0; argv[i]; i++, j++)
657     if (!i && argv[i + 1] && !strcmp (*argv, "--pass"))
658       {
659         arg_list[j] = "--env-pass";
660         setenv ("DIRMNGR_LDAP_PASS", argv[1], 1);
661         i++;
662       }
663     else
664       arg_list[j] = (char*) argv[i];
665
666   ctx = xtrycalloc (1, sizeof *ctx);
667   if (!ctx)
668     {
669       err = gpg_error_from_syserror ();
670       log_error (_("error allocating memory: %s\n"), strerror (errno));
671       xfree (arg_list);
672       return err;
673     }
674
675   err = gnupg_create_inbound_pipe (outpipe);
676   if (!err)
677     {
678       err = gnupg_create_inbound_pipe (errpipe);
679       if (err)
680         {
681           close (outpipe[0]);
682           close (outpipe[1]);
683         }
684     }
685   if (err)
686     {
687       log_error (_("error creating pipe: %s\n"), gpg_strerror (err));
688       xfree (arg_list);
689       xfree (ctx);
690       return err;
691     }
692
693   err = gnupg_spawn_process_fd (pgmname, arg_list,
694                                 -1, outpipe[1], errpipe[1], &pid);
695   xfree (arg_list);
696   close (outpipe[1]);
697   close (errpipe[1]);
698   if (err)
699     {
700       close (outpipe[0]);
701       close (errpipe[0]);
702       xfree (ctx);
703       return err;
704     }
705
706   ctx->pid = pid;
707   ctx->printable_pid = (int) pid;
708   ctx->fd = outpipe[0];
709   ctx->log_fd = errpipe[0];
710   ctx->log_ev = pth_event (PTH_EVENT_FD | PTH_UNTIL_FD_READABLE, ctx->log_fd);
711   if (! ctx->log_ev)
712     {
713       xfree (ctx);
714       return gpg_error_from_syserror ();
715     }
716   ctx->ctrl = ctrl;
717   ctrl->refcount++;
718   ctx->stamp = time (NULL);
719
720   err = ksba_reader_new (reader);
721   if (!err)
722     err = ksba_reader_set_cb (*reader, reader_callback, ctx);
723   if (err)
724     {
725       log_error (_("error initializing reader object: %s\n"),
726                  gpg_strerror (err));
727       destroy_wrapper (ctx);
728       ksba_reader_release (*reader);
729       *reader = NULL;
730       return err;
731     }
732
733   /* Hook the context into our list of running wrappers.  */
734   ctx->reader = *reader;
735   ctx->next = wrapper_list;
736   wrapper_list = ctx;
737   if (opt.verbose)
738     log_info ("ldap wrapper %d started (reader %p)\n",
739               (int)ctx->pid, ctx->reader);
740
741   /* Need to wait for the first byte so we are able to detect an empty
742      output and not let the consumer see an EOF without further error
743      indications.  The CRL loading logic assumes that after return
744      from this function, a failed search (e.g. host not found ) is
745      indicated right away. */
746   {
747     unsigned char c;
748
749     err = read_buffer (*reader, &c, 1);
750     if (err)
751       {
752         ldap_wrapper_release_context (*reader);
753         ksba_reader_release (*reader);
754         *reader = NULL;
755         if (gpg_err_code (err) == GPG_ERR_EOF)
756           return gpg_error (GPG_ERR_NO_DATA);
757         else
758           return err;
759       }
760     ksba_reader_unread (*reader, &c, 1);
761   }
762
763   return 0;
764 }
765
766
767
768 /* Perform an LDAP query.  Returns an gpg error code or 0 on success.
769    The function returns a new reader object at READER. */
770 static gpg_error_t
771 run_ldap_wrapper (ctrl_t ctrl, 
772                   int ignore_timeout,
773                   int multi_mode,
774                   const char *proxy,
775                   const char *host, int port, 
776                   const char *user, const char *pass,
777                   const char *dn, const char *filter, const char *attr,
778                   const char *url,
779                   ksba_reader_t *reader)
780 {
781   const char *argv[40];
782   int argc;
783   char portbuf[30], timeoutbuf[30];
784   
785
786   *reader = NULL;
787
788   argc = 0;
789   if (pass)  /* Note, that the password most be the first item.  */
790     {
791       argv[argc++] = "--pass";
792       argv[argc++] = pass;
793     }
794   if (opt.verbose)
795     argv[argc++] = "-vv";
796   argv[argc++] = "--log-with-pid";
797   if (multi_mode)
798     argv[argc++] = "--multi";
799   if (opt.ldaptimeout)
800     {
801       sprintf (timeoutbuf, "%u", opt.ldaptimeout);
802       argv[argc++] = "--timeout";
803       argv[argc++] = timeoutbuf;
804       if (ignore_timeout)
805         argv[argc++] = "--only-search-timeout";
806     }
807   if (proxy)
808     {
809       argv[argc++] = "--proxy";
810       argv[argc++] = proxy;
811     }
812   if (host)
813     {
814       argv[argc++] = "--host";
815       argv[argc++] = host;
816     }
817   if (port)
818     {
819       sprintf (portbuf, "%d", port);
820       argv[argc++] = "--port";
821       argv[argc++] = portbuf;
822     }
823   if (user)
824     {
825       argv[argc++] = "--user";
826       argv[argc++] = user;
827     }
828   if (dn)
829     {
830       argv[argc++] = "--dn";
831       argv[argc++] = dn;
832     }
833   if (filter)
834     {
835       argv[argc++] = "--filter";
836       argv[argc++] = filter;
837     }
838   if (attr)
839     {
840       argv[argc++] = "--attr";
841       argv[argc++] = attr;
842     }
843   argv[argc++] = url? url : "ldap://";
844   argv[argc] = NULL;
845     
846   return ldap_wrapper (ctrl, reader, argv);
847 }
848
849
850
851
852 /* Perform a LDAP query using a given URL. On success a new ksba
853    reader is returned.  If HOST or PORT are not 0, they are used to
854    override the values from the URL. */
855 gpg_error_t
856 url_fetch_ldap (ctrl_t ctrl, const char *url, const char *host, int port,
857                 ksba_reader_t *reader)
858 {
859   gpg_error_t err;
860
861   err = run_ldap_wrapper (ctrl,
862                           1, /* Ignore explicit timeout because CRLs
863                                 might be very large. */
864                           0,
865                           opt.ldap_proxy,
866                           host, port,
867                           NULL, NULL,
868                           NULL, NULL, NULL, url,
869                           reader);
870
871   /* FIXME: This option might be used for DoS attacks.  Because it
872      will enlarge the list of servers to consult without a limit and
873      all LDAP queries w/o a host are will then try each host in
874      turn. */
875   if (!err && opt.add_new_ldapservers && !opt.ldap_proxy) 
876     {
877       if (host)
878         add_server_to_servers (host, port);
879       else if (url)
880         {
881           char *tmp = host_and_port_from_url (url, &port);
882           if (tmp)
883             {
884               add_server_to_servers (tmp, port);
885               xfree (tmp);
886             }
887         }
888     }
889
890   /* If the lookup failed and we are not only using the proxy, we try
891      again using our default list of servers.  */
892   if (err && !(opt.ldap_proxy && opt.only_ldap_proxy))
893     {
894       struct ldapserver_iter iter;
895       
896       if (DBG_LOOKUP)
897         log_debug ("no hostname in URL or query failed; "
898                    "trying all default hostnames\n");
899       
900       for (ldapserver_iter_begin (&iter, ctrl);
901            err && ! ldapserver_iter_end_p (&iter);
902            ldapserver_iter_next (&iter))
903         {
904           ldap_server_t server = iter.server;
905
906           err = run_ldap_wrapper (ctrl,
907                                   0,
908                                   0,
909                                   NULL,
910                                   server->host, server->port,
911                                   NULL, NULL,
912                                   NULL, NULL, NULL, url,
913                                   reader);
914           if (!err)
915             break;
916         }
917     }
918
919   return err;
920 }
921
922
923
924 /* Perform an LDAP query on all configured servers.  On error the
925    error code of the last try is returned.  */
926 gpg_error_t
927 attr_fetch_ldap (ctrl_t ctrl,
928                  const char *dn, const char *attr, ksba_reader_t *reader)
929 {
930   gpg_error_t err = gpg_error (GPG_ERR_CONFIGURATION);
931   struct ldapserver_iter iter;
932
933   *reader = NULL;
934
935   /* FIXME; we might want to look at the Base SN to try matching
936      servers first. */
937   for (ldapserver_iter_begin (&iter, ctrl); ! ldapserver_iter_end_p (&iter);
938        ldapserver_iter_next (&iter))
939     {
940       ldap_server_t server = iter.server;
941
942       err = run_ldap_wrapper (ctrl,
943                               0,
944                               0,
945                               opt.ldap_proxy,
946                               server->host, server->port,
947                               server->user, server->pass,
948                               dn, "objectClass=*", attr, NULL,
949                               reader);
950       if (!err)
951         break; /* Probably found a result. Ready. */
952     }
953   return err;
954 }
955
956 \f
957 /* Parse PATTERN and return a new strlist to be used for the actual
958    LDAP query.  Bit 0 of the flags field is set if that pattern is
959    actually a base specification.  Caller must release the returned
960    strlist.  NULL is returned on error.
961
962  * Possible patterns:
963  *
964  *   KeyID
965  *   Fingerprint
966  *   OpenPGP userid
967  * x Email address  Indicated by a left angle bracket.
968  *   Exact word match in user id or subj. name
969  * x Subj. DN  indicated bu a leading slash
970  *   Issuer DN
971  *   Serial number + subj. DN
972  * x Substring match indicated by a leading '*; is also the default.
973  */
974
975 strlist_t
976 parse_one_pattern (const char *pattern)
977 {
978   strlist_t result = NULL;
979   char *p;
980
981   switch (*pattern)
982     {
983     case '<':                   /* Email. */
984       {
985         pattern++;
986         result = xmalloc (sizeof *result + 5 + strlen (pattern));
987         result->next = NULL;
988         result->flags = 0;
989         p = stpcpy (stpcpy (result->d, "mail="), pattern);
990         if (p[-1] == '>')
991           *--p = 0;
992         if (!*result->d) /* Error. */
993           {
994             xfree (result);
995             result = NULL;
996           }
997         break;
998       }
999     case '/':                   /* Subject DN. */
1000       pattern++;
1001       if (*pattern)
1002         {
1003           result = xmalloc (sizeof *result + strlen (pattern));
1004           result->next = NULL;
1005           result->flags = 1; /* Base spec. */
1006           strcpy (result->d, pattern);
1007         }
1008       break;
1009     case '#':                   /* Issuer DN. */
1010       pattern++;
1011       if (*pattern == '/')  /* Just issuer DN. */
1012         {
1013           pattern++;
1014         }
1015       else  /* Serial number + issuer DN */
1016         {
1017         }
1018       break;
1019     case '*':
1020       pattern++;
1021     default:                    /* Take as substring match. */
1022       {
1023         const char format[] = "(|(sn=*%s*)(|(cn=*%s*)(mail=*%s*)))";
1024         
1025         if (*pattern)
1026           {
1027             result = xmalloc (sizeof *result
1028                               + strlen (format) + 3 * strlen (pattern));
1029             result->next = NULL;
1030             result->flags = 0; 
1031             sprintf (result->d, format, pattern, pattern, pattern);
1032           }
1033       }
1034       break;
1035     }
1036   
1037   return result;
1038 }
1039
1040 /* Take the string STRING and escape it accoring to the URL rules.
1041    Retun a newly allocated string. */
1042 static char *
1043 escape4url (const char *string)
1044 {
1045   const char *s;
1046   char *buf, *p;
1047   size_t n;
1048
1049   if (!string)
1050     string = "";
1051
1052   for (s=string,n=0; *s; s++)
1053     if (strchr (UNENCODED_URL_CHARS, *s))
1054       n++;
1055     else 
1056       n += 3;
1057   
1058   buf = malloc (n+1);
1059   if (!buf)
1060     return NULL;
1061
1062   for (s=string,p=buf; *s; s++)
1063     if (strchr (UNENCODED_URL_CHARS, *s))
1064       *p++ = *s;
1065     else 
1066       {
1067         sprintf (p, "%%%02X", *(const unsigned char *)s);
1068         p += 3;
1069       }
1070   *p = 0;
1071
1072   return buf;
1073 }
1074
1075
1076
1077 /* Create a LDAP URL from DN and FILTER and return it in URL.  We don't
1078    need the host and port because this will be specified using the
1079    override options. */
1080 static gpg_error_t
1081 make_url (char **url, const char *dn, const char *filter)
1082 {
1083   gpg_error_t err;
1084   char *u_dn, *u_filter;
1085   char const attrs[] = (USERCERTIFICATE ","
1086 /*                         USERSMIMECERTIFICATE "," */
1087                         CACERTIFICATE ","
1088                         X509CACERT );
1089
1090   *url = NULL;
1091
1092   u_dn = escape4url (dn);
1093   if (!u_dn)
1094       return gpg_error_from_errno (errno);
1095
1096   u_filter = escape4url (filter);
1097   if (!u_filter)
1098     {
1099       err = gpg_error_from_errno (errno);
1100       xfree (u_dn);
1101       return err;
1102     }
1103   *url = malloc ( 8 + strlen (u_dn)
1104                  + 1 + strlen (attrs)
1105                  + 5 + strlen (u_filter) + 1 );
1106   if (!*url)
1107     {
1108       err = gpg_error_from_errno (errno);
1109       xfree (u_dn);
1110       xfree (u_filter);
1111       return err;
1112     }
1113  
1114   stpcpy (stpcpy (stpcpy (stpcpy (stpcpy (stpcpy (*url, "ldap:///"),
1115                                           u_dn),
1116                                   "?"),
1117                           attrs),
1118                   "?sub?"),
1119           u_filter);
1120   xfree (u_dn);
1121   xfree (u_filter);
1122   return 0;
1123 }
1124
1125
1126 /* Prepare an LDAP query to return the attribute ATTR for the DN.  All
1127    configured default servers are queried until one responds.  This
1128    function returns an error code or 0 and a CONTEXT on success. */
1129 gpg_error_t
1130 start_default_fetch_ldap (ctrl_t ctrl, cert_fetch_context_t *context,
1131                           const char *dn, const char *attr)
1132 {
1133   gpg_error_t err;
1134   struct ldapserver_iter iter;
1135
1136   *context = xtrycalloc (1, sizeof **context);
1137   if (!*context)
1138     return gpg_error_from_errno (errno);
1139
1140   /* FIXME; we might want to look at the Base SN to try matching
1141      servers first. */
1142   err = gpg_error (GPG_ERR_CONFIGURATION);
1143
1144   for (ldapserver_iter_begin (&iter, ctrl); ! ldapserver_iter_end_p (&iter);
1145        ldapserver_iter_next (&iter))
1146     {
1147       ldap_server_t server = iter.server;
1148
1149       err = run_ldap_wrapper (ctrl,
1150                               0,
1151                               1,
1152                               opt.ldap_proxy,
1153                               server->host, server->port,
1154                               server->user, server->pass,
1155                               dn, "objectClass=*", attr, NULL,
1156                               &(*context)->reader);
1157       if (!err)
1158         break; /* Probably found a result. */
1159     }
1160
1161   if (err)
1162     {
1163       xfree (*context);
1164       *context = NULL;
1165     }
1166   return err;
1167 }
1168
1169
1170 /* Prepare an LDAP query to return certificates maching PATTERNS using
1171    the SERVER.  This function returns an error code or 0 and a CONTEXT
1172    on success. */
1173 gpg_error_t
1174 start_cert_fetch_ldap (ctrl_t ctrl, cert_fetch_context_t *context,
1175                        strlist_t patterns, const ldap_server_t server)
1176 {
1177   gpg_error_t err;
1178   const char *host;
1179   int port;
1180   const char *user;
1181   const char *pass;
1182   const char *base;
1183   const char *argv[50];
1184   int argc;
1185   char portbuf[30], timeoutbuf[30];
1186
1187   
1188   *context = NULL;
1189   if (server)
1190     {
1191       host = server->host;
1192       port = server->port;
1193       user = server->user;
1194       pass = server->pass;
1195       base = server->base;
1196     }
1197   else /* Use a default server. */
1198     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1199
1200   if (!base)
1201     base = "";
1202
1203   argc = 0;
1204   if (pass) /* Note: Must be the first item. */
1205     {
1206       argv[argc++] = "--pass";
1207       argv[argc++] = pass;
1208     }
1209   if (opt.verbose)
1210     argv[argc++] = "-vv";
1211   argv[argc++] = "--log-with-pid";
1212   argv[argc++] = "--multi";
1213   if (opt.ldaptimeout)
1214     {
1215       sprintf (timeoutbuf, "%u", opt.ldaptimeout);
1216       argv[argc++] = "--timeout";
1217       argv[argc++] = timeoutbuf;
1218     }
1219   if (opt.ldap_proxy)
1220     {
1221       argv[argc++] = "--proxy";
1222       argv[argc++] = opt.ldap_proxy;
1223     }
1224   if (host)
1225     {
1226       argv[argc++] = "--host";
1227       argv[argc++] = host;
1228     }
1229   if (port)
1230     {
1231       sprintf (portbuf, "%d", port);
1232       argv[argc++] = "--port";
1233       argv[argc++] = portbuf;
1234     }
1235   if (user)
1236     {
1237       argv[argc++] = "--user";
1238       argv[argc++] = user;
1239     }
1240
1241
1242   for (; patterns; patterns = patterns->next)
1243     {
1244       strlist_t sl;
1245       char *url;
1246
1247       if (argc >= sizeof argv -1)
1248         {
1249           /* Too many patterns.  It does not make sense to allow an
1250              arbitrary number of patters because the length of the
1251              command line is limited anyway.  */
1252           /* fixme: cleanup. */
1253           return gpg_error (GPG_ERR_RESOURCE_LIMIT);
1254         }
1255       sl = parse_one_pattern (patterns->d);
1256       if (!sl)
1257         {
1258           log_error (_("start_cert_fetch: invalid pattern `%s'\n"),
1259                      patterns->d);
1260           /* fixme: cleanup argv.  */
1261           return gpg_error (GPG_ERR_INV_USER_ID);
1262         }
1263       if ((sl->flags & 1))
1264         err = make_url (&url, sl->d, "objectClass=*");
1265       else
1266         err = make_url (&url, base, sl->d);
1267       free_strlist (sl);
1268       if (err)
1269         {
1270           /* fixme: cleanup argv. */
1271           return err;
1272         }
1273       argv[argc++] = url;
1274     }
1275   argv[argc] = NULL;
1276
1277   *context = xtrycalloc (1, sizeof **context);
1278   if (!*context)
1279     return gpg_error_from_errno (errno);
1280
1281   err = ldap_wrapper (ctrl, &(*context)->reader, argv);
1282
1283   if (err)
1284     {
1285       xfree (*context);
1286       *context = NULL;
1287     }
1288
1289   return err;
1290 }
1291
1292
1293 /* Read a fixed amount of data from READER into BUFFER.  */
1294 static gpg_error_t
1295 read_buffer (ksba_reader_t reader, unsigned char *buffer, size_t count)
1296 {
1297   gpg_error_t err;
1298   size_t nread;
1299   
1300   while (count)
1301     {
1302       err = ksba_reader_read (reader, buffer, count, &nread);
1303       if (err)
1304         return err;
1305       buffer += nread;
1306       count -= nread;
1307     }
1308   return 0;
1309 }
1310
1311
1312 /* Fetch the next certificate. Return 0 on success, GPG_ERR_EOF if no
1313    (more) certificates are available or any other error
1314    code. GPG_ERR_TRUNCATED may be returned to indicate that the result
1315    has been truncated. */
1316 gpg_error_t
1317 fetch_next_cert_ldap (cert_fetch_context_t context,
1318                       unsigned char **value, size_t *valuelen)
1319 {
1320   gpg_error_t err;
1321   unsigned char hdr[5];
1322   char *p, *pend;
1323   int n;
1324   int okay = 0;
1325   int is_cms = 0;
1326
1327   *value = NULL;
1328   *valuelen = 0;
1329
1330   err = 0;
1331   while (!err)
1332     {
1333       err = read_buffer (context->reader, hdr, 5);
1334       if (err)
1335         break;
1336       n = (hdr[1] << 24)|(hdr[2]<<16)|(hdr[3]<<8)|hdr[4];
1337       if (*hdr == 'V' && okay)
1338         {
1339 #if 0  /* That code is not yet ready.  */
1340        
1341           if (is_cms)
1342             {
1343               /* The certificate needs to be parsed from CMS data. */
1344               ksba_cms_t cms;
1345               ksba_stop_reason_t stopreason;
1346               int i;
1347           
1348               err = ksba_cms_new (&cms);
1349               if (err)
1350                 goto leave;
1351               err = ksba_cms_set_reader_writer (cms, context->reader, NULL);
1352               if (err)
1353                 {
1354                   log_error ("ksba_cms_set_reader_writer failed: %s\n",
1355                              gpg_strerror (err));
1356                   goto leave;
1357                 }
1358
1359               do 
1360                 {
1361                   err = ksba_cms_parse (cms, &stopreason);
1362                   if (err)
1363                     {
1364                       log_error ("ksba_cms_parse failed: %s\n",
1365                                  gpg_strerror (err));
1366                       goto leave;
1367                     }
1368
1369                   if (stopreason == KSBA_SR_BEGIN_DATA)
1370                     log_error ("userSMIMECertificate is not "
1371                                "a certs-only message\n");
1372                 }
1373               while (stopreason != KSBA_SR_READY);   
1374       
1375               for (i=0; (cert=ksba_cms_get_cert (cms, i)); i++)
1376                 {
1377                   check_and_store (ctrl, stats, cert, 0);
1378                   ksba_cert_release (cert); 
1379                   cert = NULL;
1380                 }
1381               if (!i)
1382                 log_error ("no certificate found\n");
1383               else
1384                 any = 1;
1385             }
1386           else
1387 #endif
1388             {
1389               *value = xtrymalloc (n);
1390               if (!*value)
1391                 return gpg_error_from_errno (errno);
1392               *valuelen = n; 
1393               err = read_buffer (context->reader, *value, n);
1394               break; /* Ready or error.  */
1395             }
1396         }
1397       else if (!n && *hdr == 'A')
1398         okay = 0;
1399       else if (n)
1400         {
1401           if (n > context->tmpbufsize)
1402             {
1403               xfree (context->tmpbuf);
1404               context->tmpbufsize = 0;
1405               context->tmpbuf = xtrymalloc (n+1);
1406               if (!context->tmpbuf)
1407                 return gpg_error_from_errno (errno);
1408               context->tmpbufsize = n;
1409             }  
1410           err = read_buffer (context->reader, context->tmpbuf, n);
1411           if (err)
1412             break;
1413           if (*hdr == 'A')
1414             {
1415               p = context->tmpbuf;
1416               p[n] = 0; /*(we allocated one extra byte for this.)*/
1417               is_cms = 0;
1418               if ( (pend = strchr (p, ';')) )
1419                 *pend = 0; /* Strip off the extension. */
1420               if (!ascii_strcasecmp (p, USERCERTIFICATE))
1421                 {
1422                   if (DBG_LOOKUP)
1423                     log_debug ("fetch_next_cert_ldap: got attribute `%s'\n",
1424                                USERCERTIFICATE);
1425                   okay = 1;
1426                 }
1427               else if (!ascii_strcasecmp (p, CACERTIFICATE))
1428                 {
1429                   if (DBG_LOOKUP)
1430                     log_debug ("fetch_next_cert_ldap: got attribute `%s'\n",
1431                                CACERTIFICATE);
1432                   okay = 1;
1433                 }
1434               else if (!ascii_strcasecmp (p, X509CACERT))
1435                 {
1436                   if (DBG_LOOKUP)
1437                     log_debug ("fetch_next_cert_ldap: got attribute `%s'\n",
1438                                CACERTIFICATE);
1439                   okay = 1;
1440                 }
1441 /*               else if (!ascii_strcasecmp (p, USERSMIMECERTIFICATE)) */
1442 /*                 { */
1443 /*                   if (DBG_LOOKUP) */
1444 /*                     log_debug ("fetch_next_cert_ldap: got attribute `%s'\n", */
1445 /*                                USERSMIMECERTIFICATE); */
1446 /*                   okay = 1; */
1447 /*                   is_cms = 1; */
1448 /*                 } */
1449               else
1450                 {
1451                   if (DBG_LOOKUP)
1452                     log_debug ("fetch_next_cert_ldap: got attribute `%s'"
1453                                " -  ignored\n", p);
1454                   okay = 0;
1455                 }
1456             }
1457           else if (*hdr == 'E')
1458             {
1459               p = context->tmpbuf;
1460               p[n] = 0; /*(we allocated one extra byte for this.)*/
1461               if (!strcmp (p, "truncated"))
1462                 {
1463                   context->truncated = 1;
1464                   log_info (_("ldap_search hit the size limit of"
1465                               " the server\n"));
1466                 }
1467             }
1468         }
1469     }
1470
1471   if (err)
1472     {
1473       xfree (*value);
1474       *value = NULL;
1475       *valuelen = 0;
1476       if (gpg_err_code (err) == GPG_ERR_EOF && context->truncated)
1477         {
1478           context->truncated = 0; /* So that the next call would return EOF. */
1479           err = gpg_error (GPG_ERR_TRUNCATED);
1480         }
1481     }
1482
1483   return err;
1484 }
1485
1486
1487 void
1488 end_cert_fetch_ldap (cert_fetch_context_t context)
1489 {
1490   if (context)
1491     {
1492       ksba_reader_t reader = context->reader;
1493
1494       xfree (context->tmpbuf);
1495       xfree (context);
1496       ldap_wrapper_release_context (reader);
1497       ksba_reader_release (reader);
1498     }
1499 }