g10: Fix testing for debug flag.
[gnupg.git] / g10 / keyserver.c
1 /* keyserver.c - generic keyserver code
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3  *               2009, 2011, 2012 Free Software Foundation, Inc.
4  * Copyright (C) 2014 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <ctype.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <stdlib.h>
27 #include <errno.h>
28
29 #include "gpg.h"
30 #include "iobuf.h"
31 #include "filter.h"
32 #include "keydb.h"
33 #include "status.h"
34 #include "exec.h"
35 #include "main.h"
36 #include "i18n.h"
37 #include "ttyio.h"
38 #include "options.h"
39 #include "packet.h"
40 #include "trustdb.h"
41 #include "keyserver-internal.h"
42 #include "util.h"
43 #include "membuf.h"
44 #include "mbox-util.h"
45 #include "call-dirmngr.h"
46
47 #ifdef HAVE_W32_SYSTEM
48 /* It seems Vista doesn't grok X_OK and so fails access() tests.
49    Previous versions interpreted X_OK as F_OK anyway, so we'll just
50    use F_OK directly. */
51 #undef X_OK
52 #define X_OK F_OK
53 #endif /* HAVE_W32_SYSTEM */
54
55 struct keyrec
56 {
57   KEYDB_SEARCH_DESC desc;
58   u32 createtime,expiretime;
59   int size,flags;
60   byte type;
61   IOBUF uidbuf;
62   unsigned int lines;
63 };
64
65 /* Parameters for the search line handler.  */
66 struct search_line_handler_parm_s
67 {
68   ctrl_t ctrl;     /* The session control structure.  */
69   char *searchstr_disp;  /* Native encoded search string or NULL.  */
70   KEYDB_SEARCH_DESC *desc; /* Array with search descriptions.  */
71   int count;      /* Number of keys we are currently prepared to
72                      handle.  This is the size of the DESC array.  If
73                      it is too small, it will grow safely.  */
74   int validcount; /* Enable the "Key x-y of z" messages. */
75   int nkeys;      /* Number of processed records.  */
76   int any_lines;  /* At least one line has been processed.  */
77   unsigned int numlines;  /* Counter for displayed lines.  */
78   int eof_seen;   /* EOF encountered.  */
79   int not_found;  /* Set if no keys have been found.  */
80 };
81
82
83 enum ks_action {KS_UNKNOWN=0,KS_GET,KS_GETNAME,KS_SEND,KS_SEARCH};
84
85 static struct parse_options keyserver_opts[]=
86   {
87     /* some of these options are not real - just for the help
88        message */
89     {"max-cert-size",0,NULL,NULL},  /* MUST be the first in this array! */
90     {"http-proxy", KEYSERVER_HTTP_PROXY, NULL, /* MUST be the second!  */
91      N_("override proxy options set for dirmngr")},
92
93     {"include-revoked",0,NULL,N_("include revoked keys in search results")},
94     {"include-subkeys",0,NULL,N_("include subkeys when searching by key ID")},
95     {"timeout", KEYSERVER_TIMEOUT, NULL,
96      N_("override timeout options set for dirmngr")},
97     {"refresh-add-fake-v3-keyids",KEYSERVER_ADD_FAKE_V3,NULL,
98      NULL},
99     {"auto-key-retrieve",KEYSERVER_AUTO_KEY_RETRIEVE,NULL,
100      N_("automatically retrieve keys when verifying signatures")},
101     {"honor-keyserver-url",KEYSERVER_HONOR_KEYSERVER_URL,NULL,
102      N_("honor the preferred keyserver URL set on the key")},
103     {"honor-pka-record",KEYSERVER_HONOR_PKA_RECORD,NULL,
104      N_("honor the PKA record set on a key when retrieving keys")},
105     {NULL,0,NULL,NULL}
106   };
107
108 static gpg_error_t keyserver_get (ctrl_t ctrl,
109                                   KEYDB_SEARCH_DESC *desc, int ndesc,
110                                   struct keyserver_spec *override_keyserver,
111                                   unsigned char **r_fpr, size_t *r_fprlen);
112 static gpg_error_t keyserver_put (ctrl_t ctrl, strlist_t keyspecs);
113
114
115 /* Reasonable guess.  The commonly used test key simon.josefsson.org
116    is larger than 32k, thus we need at least this value. */
117 #define DEFAULT_MAX_CERT_SIZE 65536
118
119 static size_t max_cert_size=DEFAULT_MAX_CERT_SIZE;
120
121
122 static void
123 warn_kshelper_option(char *option, int noisy)
124 {
125   char *p;
126
127   if ((p=strchr (option, '=')))
128     *p = 0;
129
130   if (!strcmp (option, "ca-cert-file"))
131     log_info ("keyserver option '%s' is obsolete; please use "
132               "'%s' in dirmngr.conf\n",
133               "ca-cert-file", "hkp-cacert");
134   else if (!strcmp (option, "check-cert")
135            || !strcmp (option, "broken-http-proxy"))
136     log_info ("keyserver option '%s' is obsolete\n", option);
137   else if (noisy || opt.verbose)
138     log_info ("keyserver option '%s' is unknown\n", option);
139 }
140
141
142 /* Called from main to parse the args for --keyserver-options.  */
143 int
144 parse_keyserver_options(char *options)
145 {
146   int ret=1;
147   char *tok;
148   char *max_cert=NULL;
149
150   keyserver_opts[0].value=&max_cert;
151   keyserver_opts[1].value=&opt.keyserver_options.http_proxy;
152
153   while((tok=optsep(&options)))
154     {
155       if(tok[0]=='\0')
156         continue;
157
158       /* We accept quite a few possible options here - some options to
159          handle specially, the keyserver_options list, and import and
160          export options that pertain to keyserver operations.  */
161
162       if (!parse_options (tok,&opt.keyserver_options.options, keyserver_opts,0)
163           && !parse_import_options(tok,&opt.keyserver_options.import_options,0)
164           && !parse_export_options(tok,&opt.keyserver_options.export_options,0))
165         {
166           /* All of the standard options have failed, so the option was
167              destined for a keyserver plugin as used by GnuPG < 2.1 */
168           warn_kshelper_option (tok, 1);
169         }
170     }
171
172   if(max_cert)
173     {
174       max_cert_size=strtoul(max_cert,(char **)NULL,10);
175
176       if(max_cert_size==0)
177         max_cert_size=DEFAULT_MAX_CERT_SIZE;
178     }
179
180   return ret;
181 }
182
183
184 void
185 free_keyserver_spec(struct keyserver_spec *keyserver)
186 {
187   xfree(keyserver->uri);
188   xfree(keyserver->scheme);
189   xfree(keyserver->auth);
190   xfree(keyserver->host);
191   xfree(keyserver->port);
192   xfree(keyserver->path);
193   xfree(keyserver->opaque);
194   free_strlist(keyserver->options);
195   xfree(keyserver);
196 }
197
198 /* Return 0 for match */
199 static int
200 cmp_keyserver_spec(struct keyserver_spec *one,struct keyserver_spec *two)
201 {
202   if(ascii_strcasecmp(one->scheme,two->scheme)==0)
203     {
204       if(one->host && two->host && ascii_strcasecmp(one->host,two->host)==0)
205         {
206           if((one->port && two->port
207               && ascii_strcasecmp(one->port,two->port)==0)
208              || (!one->port && !two->port))
209             return 0;
210         }
211       else if(one->opaque && two->opaque
212               && ascii_strcasecmp(one->opaque,two->opaque)==0)
213         return 0;
214     }
215
216   return 1;
217 }
218
219 /* Try and match one of our keyservers.  If we can, return that.  If
220    we can't, return our input. */
221 struct keyserver_spec *
222 keyserver_match(struct keyserver_spec *spec)
223 {
224   struct keyserver_spec *ks;
225
226   for(ks=opt.keyserver;ks;ks=ks->next)
227     if(cmp_keyserver_spec(spec,ks)==0)
228       return ks;
229
230   return spec;
231 }
232
233 /* TODO: once we cut over to an all-curl world, we don't need this
234    parser any longer so it can be removed, or at least moved to
235    keyserver/ksutil.c for limited use in gpgkeys_ldap or the like. */
236
237 keyserver_spec_t
238 parse_keyserver_uri (const char *string,int require_scheme)
239 {
240   int assume_hkp=0;
241   struct keyserver_spec *keyserver;
242   const char *idx;
243   int count;
244   char *uri, *duped_uri, *options;
245
246   log_assert (string);
247
248   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
249
250   duped_uri = uri = xstrdup (string);
251
252   options=strchr(uri,' ');
253   if(options)
254     {
255       char *tok;
256
257       *options='\0';
258       options++;
259
260       while((tok=optsep(&options)))
261         warn_kshelper_option (tok, 0);
262     }
263
264   /* Get the scheme */
265
266   for(idx=uri,count=0;*idx && *idx!=':';idx++)
267     {
268       count++;
269
270       /* Do we see the start of an RFC-2732 ipv6 address here?  If so,
271          there clearly isn't a scheme so get out early. */
272       if(*idx=='[')
273         {
274           /* Was the '[' the first thing in the string?  If not, we
275              have a mangled scheme with a [ in it so fail. */
276           if(count==1)
277             break;
278           else
279             goto fail;
280         }
281     }
282
283   if(count==0)
284     goto fail;
285
286   if(*idx=='\0' || *idx=='[')
287     {
288       if(require_scheme)
289         return NULL;
290
291       /* Assume HKP if there is no scheme */
292       assume_hkp=1;
293       keyserver->scheme=xstrdup("hkp");
294
295       keyserver->uri=xmalloc(strlen(keyserver->scheme)+3+strlen(uri)+1);
296       strcpy(keyserver->uri,keyserver->scheme);
297       strcat(keyserver->uri,"://");
298       strcat(keyserver->uri,uri);
299     }
300   else
301     {
302       int i;
303
304       keyserver->uri=xstrdup(uri);
305
306       keyserver->scheme=xmalloc(count+1);
307
308       /* Force to lowercase */
309       for(i=0;i<count;i++)
310         keyserver->scheme[i]=ascii_tolower(uri[i]);
311
312       keyserver->scheme[i]='\0';
313
314       /* Skip past the scheme and colon */
315       uri+=count+1;
316     }
317
318   if(ascii_strcasecmp(keyserver->scheme,"x-broken-hkp")==0)
319     {
320       log_info ("keyserver option '%s' is obsolete\n",
321                 "x-broken-hkp");
322     }
323   else if(ascii_strcasecmp(keyserver->scheme,"x-hkp")==0)
324     {
325       /* Canonicalize this to "hkp" so it works with both the internal
326          and external keyserver interface. */
327       xfree(keyserver->scheme);
328       keyserver->scheme=xstrdup("hkp");
329     }
330
331   if (uri[0]=='/' && uri[1]=='/' && uri[2] == '/')
332     {
333       /* Three slashes means network path with a default host name.
334          This is a hack because it does not crok all possible
335          combiantions.  We should better repalce all code bythe parser
336          from http.c.  */
337       keyserver->path = xstrdup (uri+2);
338     }
339   else if(assume_hkp || (uri[0]=='/' && uri[1]=='/'))
340     {
341       /* Two slashes means network path. */
342
343       /* Skip over the "//", if any */
344       if(!assume_hkp)
345         uri+=2;
346
347       /* Do we have userinfo auth data present? */
348       for(idx=uri,count=0;*idx && *idx!='@' && *idx!='/';idx++)
349         count++;
350
351       /* We found a @ before the slash, so that means everything
352          before the @ is auth data. */
353       if(*idx=='@')
354         {
355           if(count==0)
356             goto fail;
357
358           keyserver->auth=xmalloc(count+1);
359           strncpy(keyserver->auth,uri,count);
360           keyserver->auth[count]='\0';
361           uri+=count+1;
362         }
363
364       /* Is it an RFC-2732 ipv6 [literal address] ? */
365       if(*uri=='[')
366         {
367           for(idx=uri+1,count=1;*idx
368                 && ((isascii (*idx) && isxdigit(*idx))
369                     || *idx==':' || *idx=='.');idx++)
370             count++;
371
372           /* Is the ipv6 literal address terminated? */
373           if(*idx==']')
374             count++;
375           else
376             goto fail;
377         }
378       else
379         for(idx=uri,count=0;*idx && *idx!=':' && *idx!='/';idx++)
380           count++;
381
382       if(count==0)
383         goto fail;
384
385       keyserver->host=xmalloc(count+1);
386       strncpy(keyserver->host,uri,count);
387       keyserver->host[count]='\0';
388
389       /* Skip past the host */
390       uri+=count;
391
392       if(*uri==':')
393         {
394           /* It would seem to be reasonable to limit the range of the
395              ports to values between 1-65535, but RFC 1738 and 1808
396              imply there is no limit.  Of course, the real world has
397              limits. */
398
399           for(idx=uri+1,count=0;*idx && *idx!='/';idx++)
400             {
401               count++;
402
403               /* Ports are digits only */
404               if(!digitp(idx))
405                 goto fail;
406             }
407
408           keyserver->port=xmalloc(count+1);
409           strncpy(keyserver->port,uri+1,count);
410           keyserver->port[count]='\0';
411
412           /* Skip past the colon and port number */
413           uri+=1+count;
414         }
415
416       /* Everything else is the path */
417       if(*uri)
418         keyserver->path=xstrdup(uri);
419       else
420         keyserver->path=xstrdup("/");
421
422       if(keyserver->path[1])
423         keyserver->flags.direct_uri=1;
424     }
425   else if(uri[0]!='/')
426     {
427       /* No slash means opaque.  Just record the opaque blob and get
428          out. */
429       keyserver->opaque=xstrdup(uri);
430     }
431   else
432     {
433       /* One slash means absolute path.  We don't need to support that
434          yet. */
435       goto fail;
436     }
437
438   xfree (duped_uri);
439   return keyserver;
440
441  fail:
442   free_keyserver_spec(keyserver);
443
444   xfree (duped_uri);
445   return NULL;
446 }
447
448 struct keyserver_spec *
449 parse_preferred_keyserver(PKT_signature *sig)
450 {
451   struct keyserver_spec *spec=NULL;
452   const byte *p;
453   size_t plen;
454
455   p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&plen);
456   if(p && plen)
457     {
458       byte *dupe=xmalloc(plen+1);
459
460       memcpy(dupe,p,plen);
461       dupe[plen]='\0';
462       spec = parse_keyserver_uri (dupe, 1);
463       xfree(dupe);
464     }
465
466   return spec;
467 }
468
469 static void
470 print_keyrec(int number,struct keyrec *keyrec)
471 {
472   int i;
473
474   iobuf_writebyte(keyrec->uidbuf,0);
475   iobuf_flush_temp(keyrec->uidbuf);
476   es_printf ("(%d)\t%s  ", number, iobuf_get_temp_buffer (keyrec->uidbuf));
477
478   if (keyrec->size>0)
479     es_printf ("%d bit ", keyrec->size);
480
481   if(keyrec->type)
482     {
483       const char *str;
484
485       str = openpgp_pk_algo_name (keyrec->type);
486
487       if (str && strcmp (str, "?"))
488         es_printf ("%s ",str);
489       else
490         es_printf ("unknown ");
491     }
492
493   switch(keyrec->desc.mode)
494     {
495       /* If the keyserver helper gave us a short keyid, we have no
496          choice but to use it.  Do check --keyid-format to add a 0x if
497          needed. */
498     case KEYDB_SEARCH_MODE_SHORT_KID:
499       es_printf ("key %s%08lX",
500                  (opt.keyid_format==KF_0xSHORT
501                   || opt.keyid_format==KF_0xLONG)?"0x":"",
502                  (ulong)keyrec->desc.u.kid[1]);
503       break;
504
505       /* However, if it gave us a long keyid, we can honor
506          --keyid-format via keystr(). */
507     case KEYDB_SEARCH_MODE_LONG_KID:
508       es_printf ("key %s",keystr(keyrec->desc.u.kid));
509       break;
510
511       /* If it gave us a PGP 2.x fingerprint, not much we can do
512          beyond displaying it. */
513     case KEYDB_SEARCH_MODE_FPR16:
514       es_printf ("key ");
515       for(i=0;i<16;i++)
516         es_printf ("%02X",keyrec->desc.u.fpr[i]);
517       break;
518
519       /* If we get a modern fingerprint, we have the most
520          flexibility. */
521     case KEYDB_SEARCH_MODE_FPR20:
522       {
523         u32 kid[2];
524         keyid_from_fingerprint(keyrec->desc.u.fpr,20,kid);
525         es_printf("key %s",keystr(kid));
526       }
527       break;
528
529     default:
530       BUG();
531       break;
532     }
533
534   if(keyrec->createtime>0)
535     {
536       es_printf (", ");
537       es_printf (_("created: %s"), strtimestamp(keyrec->createtime));
538     }
539
540   if(keyrec->expiretime>0)
541     {
542       es_printf (", ");
543       es_printf (_("expires: %s"), strtimestamp(keyrec->expiretime));
544     }
545
546   if (keyrec->flags&1)
547     es_printf (" (%s)", _("revoked"));
548   if(keyrec->flags&2)
549     es_printf (" (%s)", _("disabled"));
550   if(keyrec->flags&4)
551     es_printf (" (%s)", _("expired"));
552
553   es_printf ("\n");
554 }
555
556 /* Returns a keyrec (which must be freed) once a key is complete, and
557    NULL otherwise.  Call with a NULL keystring once key parsing is
558    complete to return any unfinished keys. */
559 static struct keyrec *
560 parse_keyrec(char *keystring)
561 {
562   /* FIXME: Remove the static and put the data into the parms we use
563      for the caller anyway.  */
564   static struct keyrec *work=NULL;
565   struct keyrec *ret=NULL;
566   char *record;
567   int i;
568
569   if(keystring==NULL)
570     {
571       if(work==NULL)
572         return NULL;
573       else if(work->desc.mode==KEYDB_SEARCH_MODE_NONE)
574         {
575           xfree(work);
576           return NULL;
577         }
578       else
579         {
580           ret=work;
581           work=NULL;
582           return ret;
583         }
584     }
585
586   if(work==NULL)
587     {
588       work=xmalloc_clear(sizeof(struct keyrec));
589       work->uidbuf=iobuf_temp();
590     }
591
592   trim_trailing_ws (keystring, strlen (keystring));
593
594   if((record=strsep(&keystring,":"))==NULL)
595     return ret;
596
597   if(ascii_strcasecmp("pub",record)==0)
598     {
599       char *tok;
600       gpg_error_t err;
601
602       if(work->desc.mode)
603         {
604           ret=work;
605           work=xmalloc_clear(sizeof(struct keyrec));
606           work->uidbuf=iobuf_temp();
607         }
608
609       if((tok=strsep(&keystring,":"))==NULL)
610         return ret;
611
612       err = classify_user_id (tok, &work->desc, 1);
613       if (err || (work->desc.mode    != KEYDB_SEARCH_MODE_SHORT_KID
614                   && work->desc.mode != KEYDB_SEARCH_MODE_LONG_KID
615                   && work->desc.mode != KEYDB_SEARCH_MODE_FPR16
616                   && work->desc.mode != KEYDB_SEARCH_MODE_FPR20))
617         {
618           work->desc.mode=KEYDB_SEARCH_MODE_NONE;
619           return ret;
620         }
621
622       /* Note all items after this are optional.  This allows us to
623          have a pub line as simple as pub:keyid and nothing else. */
624
625       work->lines++;
626
627       if((tok=strsep(&keystring,":"))==NULL)
628         return ret;
629
630       work->type=atoi(tok);
631
632       if((tok=strsep(&keystring,":"))==NULL)
633         return ret;
634
635       work->size=atoi(tok);
636
637       if((tok=strsep(&keystring,":"))==NULL)
638         return ret;
639
640       if(atoi(tok)<=0)
641         work->createtime=0;
642       else
643         work->createtime=atoi(tok);
644
645       if((tok=strsep(&keystring,":"))==NULL)
646         return ret;
647
648       if(atoi(tok)<=0)
649         work->expiretime=0;
650       else
651         {
652           work->expiretime=atoi(tok);
653           /* Force the 'e' flag on if this key is expired. */
654           if(work->expiretime<=make_timestamp())
655             work->flags|=4;
656         }
657
658       if((tok=strsep(&keystring,":"))==NULL)
659         return ret;
660
661       while(*tok)
662         switch(*tok++)
663           {
664           case 'r':
665           case 'R':
666             work->flags|=1;
667             break;
668
669           case 'd':
670           case 'D':
671             work->flags|=2;
672             break;
673
674           case 'e':
675           case 'E':
676             work->flags|=4;
677             break;
678           }
679     }
680   else if(ascii_strcasecmp("uid",record)==0 && work->desc.mode)
681     {
682       char *userid,*tok,*decoded;
683
684       if((tok=strsep(&keystring,":"))==NULL)
685         return ret;
686
687       if(strlen(tok)==0)
688         return ret;
689
690       userid=tok;
691
692       /* By definition, de-%-encoding is always smaller than the
693          original string so we can decode in place. */
694
695       i=0;
696
697       while(*tok)
698         if(tok[0]=='%' && tok[1] && tok[2])
699           {
700             int c;
701
702             userid[i] = (c=hextobyte(&tok[1])) == -1 ? '?' : c;
703             i++;
704             tok+=3;
705           }
706         else
707           userid[i++]=*tok++;
708
709       /* We don't care about the other info provided in the uid: line
710          since no keyserver supports marking userids with timestamps
711          or revoked/expired/disabled yet. */
712
713       /* No need to check for control characters, as utf8_to_native
714          does this for us. */
715
716       decoded=utf8_to_native(userid,i,0);
717       if(strlen(decoded)>opt.screen_columns-10)
718         decoded[opt.screen_columns-10]='\0';
719       iobuf_writestr(work->uidbuf,decoded);
720       xfree(decoded);
721       iobuf_writestr(work->uidbuf,"\n\t");
722       work->lines++;
723     }
724
725   /* Ignore any records other than "pri" and "uid" for easy future
726      growth. */
727
728   return ret;
729 }
730
731 /* Show a prompt and allow the user to select keys for retrieval.  */
732 static gpg_error_t
733 show_prompt (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int numdesc,
734              int count, const char *search)
735 {
736   gpg_error_t err;
737   char *answer = NULL;
738
739   es_fflush (es_stdout);
740
741   if (count && opt.command_fd == -1)
742     {
743       static int from = 1;
744       tty_printf ("Keys %d-%d of %d for \"%s\".  ",
745                   from, numdesc, count, search);
746       from = numdesc + 1;
747     }
748
749  again:
750   err = 0;
751   xfree (answer);
752   answer = cpr_get_no_help ("keysearch.prompt",
753                             _("Enter number(s), N)ext, or Q)uit > "));
754   /* control-d */
755   if (answer[0]=='\x04')
756     {
757       tty_printf ("Q\n");
758       answer[0] = 'q';
759     }
760
761   if (answer[0]=='q' || answer[0]=='Q')
762     err = gpg_error (GPG_ERR_CANCELED);
763   else if (atoi (answer) >= 1 && atoi (answer) <= numdesc)
764     {
765       char *split = answer;
766       char *num;
767       int numarray[50];
768       int numidx = 0;
769       int idx;
770
771       while ((num = strsep (&split, " ,")))
772         if (atoi (num) >= 1 && atoi (num) <= numdesc)
773           {
774             if (numidx >= DIM (numarray))
775               {
776                 tty_printf ("Too many keys selected\n");
777                 goto again;
778               }
779             numarray[numidx++] = atoi (num);
780           }
781
782       if (!numidx)
783         goto again;
784
785       {
786         KEYDB_SEARCH_DESC *selarray;
787
788         selarray = xtrymalloc (numidx * sizeof *selarray);
789         if (!selarray)
790           {
791             err = gpg_error_from_syserror ();
792             goto leave;
793           }
794         for (idx = 0; idx < numidx; idx++)
795           selarray[idx] = desc[numarray[idx]-1];
796         err = keyserver_get (ctrl, selarray, numidx, NULL, NULL, NULL);
797         xfree (selarray);
798       }
799     }
800
801  leave:
802   xfree (answer);
803   return err;
804 }
805
806
807 /* This is a callback used by call-dirmngr.c to process the result of
808    KS_SEARCH command.  If SPECIAL is 0, LINE is the actual data line
809    received with all escaping removed and guaranteed to be exactly one
810    line with stripped LF; an EOF is indicated by LINE passed as NULL.
811    If special is 1, the line contains the source of the information
812    (usually an URL).  LINE may be modified after return.  */
813 static gpg_error_t
814 search_line_handler (void *opaque, int special, char *line)
815 {
816   struct search_line_handler_parm_s *parm = opaque;
817   gpg_error_t err = 0;
818   struct keyrec *keyrec;
819
820   if (special == 1)
821     {
822       log_info ("data source: %s\n", line);
823       return 0;
824     }
825   else if (special)
826     {
827       log_debug ("unknown value %d for special search callback", special);
828       return 0;
829     }
830
831   if (parm->eof_seen && line)
832     {
833       log_debug ("ooops: unexpected data after EOF\n");
834       line = NULL;
835     }
836
837   /* Print the received line.  */
838   if (opt.with_colons && line)
839     {
840       es_printf ("%s\n", line);
841     }
842
843   /* Look for an info: line.  The only current info: values defined
844      are the version and key count. */
845   if (line && !parm->any_lines && !ascii_strncasecmp ("info:", line, 5))
846     {
847       char *str = line + 5;
848       char *tok;
849
850       if ((tok = strsep (&str, ":")))
851         {
852           int version;
853
854           if (sscanf (tok, "%d", &version) !=1 )
855             version = 1;
856
857           if (version !=1 )
858             {
859               log_error (_("invalid keyserver protocol "
860                            "(us %d!=handler %d)\n"), 1, version);
861               return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
862             }
863         }
864
865       if ((tok = strsep (&str, ":"))
866           && sscanf (tok, "%d", &parm->count) == 1)
867         {
868           if (!parm->count)
869             parm->not_found = 1;/* Server indicated that no items follow.  */
870           else if (parm->count < 0)
871             parm->count = 10;   /* Bad value - assume something reasonable.  */
872           else
873             parm->validcount = 1; /* COUNT seems to be okay.  */
874         }
875
876       parm->any_lines = 1;
877       return 0; /* Line processing finished.  */
878     }
879
880  again:
881   if (line)
882     keyrec = parse_keyrec (line);
883   else
884     {
885       /* Received EOF - flush data */
886       parm->eof_seen = 1;
887       keyrec = parse_keyrec (NULL);
888       if (!keyrec)
889         {
890           if (!parm->nkeys)
891             parm->not_found = 1;  /* No keys at all.  */
892           else
893             {
894               if (parm->nkeys != parm->count)
895                 parm->validcount = 0;
896
897               if (!(opt.with_colons && opt.batch))
898                 {
899                   err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
900                                      parm->validcount? parm->count : 0,
901                                      parm->searchstr_disp);
902                   return err;
903                 }
904             }
905         }
906     }
907
908   /* Save the key in the key array.  */
909   if (keyrec)
910     {
911       /* Allocate or enlarge the key array if needed.  */
912       if (!parm->desc)
913         {
914           if (parm->count < 1)
915             {
916               parm->count = 10;
917               parm->validcount = 0;
918             }
919           parm->desc = xtrymalloc (parm->count * sizeof *parm->desc);
920           if (!parm->desc)
921             {
922               err = gpg_error_from_syserror ();
923               iobuf_close (keyrec->uidbuf);
924               xfree (keyrec);
925               return err;
926             }
927         }
928       else if (parm->nkeys == parm->count)
929         {
930           /* Keyserver sent more keys than claimed in the info: line. */
931           KEYDB_SEARCH_DESC *tmp;
932           int newcount = parm->count + 10;
933
934           tmp = xtryrealloc (parm->desc, newcount * sizeof *parm->desc);
935           if (!tmp)
936             {
937               err = gpg_error_from_syserror ();
938               iobuf_close (keyrec->uidbuf);
939               xfree (keyrec);
940               return err;
941             }
942           parm->count = newcount;
943           parm->desc = tmp;
944           parm->validcount = 0;
945         }
946
947       parm->desc[parm->nkeys] = keyrec->desc;
948
949       if (!opt.with_colons)
950         {
951           /* SCREEN_LINES - 1 for the prompt. */
952           if (parm->numlines + keyrec->lines > opt.screen_lines - 1)
953             {
954               err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
955                                  parm->validcount ? parm->count:0,
956                                  parm->searchstr_disp);
957               if (err)
958                 return err;
959               parm->numlines = 0;
960             }
961
962           print_keyrec (parm->nkeys+1, keyrec);
963         }
964
965       parm->numlines += keyrec->lines;
966       iobuf_close (keyrec->uidbuf);
967       xfree (keyrec);
968
969       parm->any_lines = 1;
970       parm->nkeys++;
971
972       /* If we are here due to a flush after the EOF, run again for
973          the last prompt.  Fixme: Make this code better readable. */
974       if (parm->eof_seen)
975         goto again;
976     }
977
978   return 0;
979 }
980
981
982
983 int
984 keyserver_export (ctrl_t ctrl, strlist_t users)
985 {
986   gpg_error_t err;
987   strlist_t sl=NULL;
988   KEYDB_SEARCH_DESC desc;
989   int rc=0;
990
991   /* Weed out descriptors that we don't support sending */
992   for(;users;users=users->next)
993     {
994       err = classify_user_id (users->d, &desc, 1);
995       if (err || (desc.mode    != KEYDB_SEARCH_MODE_SHORT_KID
996                   && desc.mode != KEYDB_SEARCH_MODE_LONG_KID
997                   && desc.mode != KEYDB_SEARCH_MODE_FPR16
998                   && desc.mode != KEYDB_SEARCH_MODE_FPR20))
999         {
1000           log_error(_("\"%s\" not a key ID: skipping\n"),users->d);
1001           continue;
1002         }
1003       else
1004         append_to_strlist(&sl,users->d);
1005     }
1006
1007   if(sl)
1008     {
1009       rc = keyserver_put (ctrl, sl);
1010       free_strlist(sl);
1011     }
1012
1013   return rc;
1014 }
1015
1016
1017 /* Structure to convey the arg to keyserver_retrieval_screener.  */
1018 struct ks_retrieval_screener_arg_s
1019 {
1020   KEYDB_SEARCH_DESC *desc;
1021   int ndesc;
1022 };
1023
1024
1025 /* Check whether a key matches the search description.  The function
1026    returns 0 if the key shall be imported.  */
1027 static gpg_error_t
1028 keyserver_retrieval_screener (kbnode_t keyblock, void *opaque)
1029 {
1030   struct ks_retrieval_screener_arg_s *arg = opaque;
1031   KEYDB_SEARCH_DESC *desc = arg->desc;
1032   int ndesc = arg->ndesc;
1033   kbnode_t node;
1034   PKT_public_key *pk;
1035   int n;
1036   u32 keyid[2];
1037   byte fpr[MAX_FINGERPRINT_LEN];
1038   size_t fpr_len = 0;
1039
1040   /* Secret keys are not expected from a keyserver.  We do not
1041      care about secret subkeys because the import code takes care
1042      of skipping them.  Not allowing an import of a public key
1043      with a secret subkey would make it too easy to inhibit the
1044      downloading of a public key.  Recall that keyservers do only
1045      limited checks.  */
1046   node = find_kbnode (keyblock, PKT_SECRET_KEY);
1047   if (node)
1048     return gpg_error (GPG_ERR_GENERAL);   /* Do not import. */
1049
1050   if (!ndesc)
1051     return 0; /* Okay if no description given.  */
1052
1053   /* Loop over all key packets.  */
1054   for (node = keyblock; node; node = node->next)
1055     {
1056       if (node->pkt->pkttype != PKT_PUBLIC_KEY
1057           && node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
1058         continue;
1059
1060       pk = node->pkt->pkt.public_key;
1061       fingerprint_from_pk (pk, fpr, &fpr_len);
1062       keyid_from_pk (pk, keyid);
1063
1064       /* Compare requested and returned fingerprints if available. */
1065       for (n = 0; n < ndesc; n++)
1066         {
1067           if (desc[n].mode == KEYDB_SEARCH_MODE_FPR20)
1068             {
1069               if (fpr_len == 20 && !memcmp (fpr, desc[n].u.fpr, 20))
1070                 return 0;
1071             }
1072           else if (desc[n].mode == KEYDB_SEARCH_MODE_FPR16)
1073             {
1074               if (fpr_len == 16 && !memcmp (fpr, desc[n].u.fpr, 16))
1075                 return 0;
1076             }
1077           else if (desc[n].mode == KEYDB_SEARCH_MODE_LONG_KID)
1078             {
1079               if (keyid[0] == desc[n].u.kid[0] && keyid[1] == desc[n].u.kid[1])
1080                 return 0;
1081             }
1082           else if (desc[n].mode == KEYDB_SEARCH_MODE_SHORT_KID)
1083             {
1084               if (keyid[1] == desc[n].u.kid[1])
1085                 return 0;
1086             }
1087           else /* No keyid or fingerprint - can't check.  */
1088             return 0; /* allow import.  */
1089         }
1090     }
1091
1092   return gpg_error (GPG_ERR_GENERAL);
1093 }
1094
1095
1096 int
1097 keyserver_import (ctrl_t ctrl, strlist_t users)
1098 {
1099   gpg_error_t err;
1100   KEYDB_SEARCH_DESC *desc;
1101   int num=100,count=0;
1102   int rc=0;
1103
1104   /* Build a list of key ids */
1105   desc=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
1106
1107   for(;users;users=users->next)
1108     {
1109       err = classify_user_id (users->d, &desc[count], 1);
1110       if (err || (desc[count].mode    != KEYDB_SEARCH_MODE_SHORT_KID
1111                   && desc[count].mode != KEYDB_SEARCH_MODE_LONG_KID
1112                   && desc[count].mode != KEYDB_SEARCH_MODE_FPR16
1113                   && desc[count].mode != KEYDB_SEARCH_MODE_FPR20))
1114         {
1115           log_error (_("\"%s\" not a key ID: skipping\n"), users->d);
1116           continue;
1117         }
1118
1119       count++;
1120       if(count==num)
1121         {
1122           num+=100;
1123           desc=xrealloc(desc,sizeof(KEYDB_SEARCH_DESC)*num);
1124         }
1125     }
1126
1127   if(count>0)
1128     rc=keyserver_get (ctrl, desc, count, NULL, NULL, NULL);
1129
1130   xfree(desc);
1131
1132   return rc;
1133 }
1134
1135
1136 /* Return true if any keyserver has been configured. */
1137 int
1138 keyserver_any_configured (ctrl_t ctrl)
1139 {
1140   return !gpg_dirmngr_ks_list (ctrl, NULL);
1141 }
1142
1143
1144 /* Import all keys that exactly match NAME */
1145 int
1146 keyserver_import_name (ctrl_t ctrl, const char *name,
1147                        unsigned char **fpr, size_t *fprlen,
1148                        struct keyserver_spec *keyserver)
1149 {
1150   KEYDB_SEARCH_DESC desc;
1151
1152   memset (&desc, 0, sizeof desc);
1153
1154   desc.mode = KEYDB_SEARCH_MODE_EXACT;
1155   desc.u.name = name;
1156
1157   return keyserver_get (ctrl, &desc, 1, keyserver, fpr, fprlen);
1158 }
1159
1160
1161 int
1162 keyserver_import_fprint (ctrl_t ctrl, const byte *fprint,size_t fprint_len,
1163                          struct keyserver_spec *keyserver)
1164 {
1165   KEYDB_SEARCH_DESC desc;
1166
1167   memset(&desc,0,sizeof(desc));
1168
1169   if(fprint_len==16)
1170     desc.mode=KEYDB_SEARCH_MODE_FPR16;
1171   else if(fprint_len==20)
1172     desc.mode=KEYDB_SEARCH_MODE_FPR20;
1173   else
1174     return -1;
1175
1176   memcpy(desc.u.fpr,fprint,fprint_len);
1177
1178   /* TODO: Warn here if the fingerprint we got doesn't match the one
1179      we asked for? */
1180   return keyserver_get (ctrl, &desc, 1, keyserver, NULL, NULL);
1181 }
1182
1183 int
1184 keyserver_import_keyid (ctrl_t ctrl,
1185                         u32 *keyid,struct keyserver_spec *keyserver)
1186 {
1187   KEYDB_SEARCH_DESC desc;
1188
1189   memset(&desc,0,sizeof(desc));
1190
1191   desc.mode=KEYDB_SEARCH_MODE_LONG_KID;
1192   desc.u.kid[0]=keyid[0];
1193   desc.u.kid[1]=keyid[1];
1194
1195   return keyserver_get (ctrl, &desc,1, keyserver, NULL, NULL);
1196 }
1197
1198 /* code mostly stolen from do_export_stream */
1199 static int
1200 keyidlist(strlist_t users,KEYDB_SEARCH_DESC **klist,int *count,int fakev3)
1201 {
1202   int rc = 0;
1203   int num = 100;
1204   kbnode_t keyblock = NULL;
1205   kbnode_t node;
1206   KEYDB_HANDLE kdbhd;
1207   int ndesc;
1208   KEYDB_SEARCH_DESC *desc = NULL;
1209   strlist_t sl;
1210
1211   *count=0;
1212
1213   *klist=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
1214
1215   kdbhd = keydb_new ();
1216   if (!kdbhd)
1217     {
1218       rc = gpg_error_from_syserror ();
1219       goto leave;
1220     }
1221   keydb_disable_caching (kdbhd);  /* We are looping the search.  */
1222
1223   if(!users)
1224     {
1225       ndesc = 1;
1226       desc = xmalloc_clear ( ndesc * sizeof *desc);
1227       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1228     }
1229   else
1230     {
1231       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
1232         ;
1233       desc = xmalloc ( ndesc * sizeof *desc);
1234
1235       for (ndesc=0, sl=users; sl; sl = sl->next)
1236         {
1237           gpg_error_t err;
1238           if (!(err = classify_user_id (sl->d, desc+ndesc, 1)))
1239             ndesc++;
1240           else
1241             log_error (_("key \"%s\" not found: %s\n"),
1242                        sl->d, gpg_strerror (err));
1243         }
1244     }
1245
1246   for (;;)
1247     {
1248       rc = keydb_search (kdbhd, desc, ndesc, NULL);
1249       if (rc)
1250         break;  /* ready.  */
1251
1252       if (!users)
1253         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1254
1255       /* read the keyblock */
1256       rc = keydb_get_keyblock (kdbhd, &keyblock );
1257       if( rc )
1258         {
1259           log_error (_("error reading keyblock: %s\n"), gpg_strerror (rc) );
1260           goto leave;
1261         }
1262
1263       if((node=find_kbnode(keyblock,PKT_PUBLIC_KEY)))
1264         {
1265           /* This is to work around a bug in some keyservers (pksd and
1266              OKS) that calculate v4 RSA keyids as if they were v3 RSA.
1267              The answer is to refresh both the correct v4 keyid
1268              (e.g. 99242560) and the fake v3 keyid (e.g. 68FDDBC7).
1269              This only happens for key refresh using the HKP scheme
1270              and if the refresh-add-fake-v3-keyids keyserver option is
1271              set. */
1272           if(fakev3 && is_RSA(node->pkt->pkt.public_key->pubkey_algo) &&
1273              node->pkt->pkt.public_key->version>=4)
1274             {
1275               (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
1276               v3_keyid (node->pkt->pkt.public_key->pkey[0],
1277                         (*klist)[*count].u.kid);
1278               (*count)++;
1279
1280               if(*count==num)
1281                 {
1282                   num+=100;
1283                   *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
1284                 }
1285             }
1286
1287           /* v4 keys get full fingerprints.  v3 keys get long keyids.
1288              This is because it's easy to calculate any sort of keyid
1289              from a v4 fingerprint, but not a v3 fingerprint. */
1290
1291           if(node->pkt->pkt.public_key->version<4)
1292             {
1293               (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
1294               keyid_from_pk(node->pkt->pkt.public_key,
1295                             (*klist)[*count].u.kid);
1296             }
1297           else
1298             {
1299               size_t dummy;
1300
1301               (*klist)[*count].mode=KEYDB_SEARCH_MODE_FPR20;
1302               fingerprint_from_pk(node->pkt->pkt.public_key,
1303                                   (*klist)[*count].u.fpr,&dummy);
1304             }
1305
1306           /* This is a little hackish, using the skipfncvalue as a
1307              void* pointer to the keyserver spec, but we don't need
1308              the skipfnc here, and it saves having an additional field
1309              for this (which would be wasted space most of the
1310              time). */
1311
1312           (*klist)[*count].skipfncvalue=NULL;
1313
1314           /* Are we honoring preferred keyservers? */
1315           if(opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1316             {
1317               PKT_user_id *uid=NULL;
1318               PKT_signature *sig=NULL;
1319
1320               merge_keys_and_selfsig(keyblock);
1321
1322               for(node=node->next;node;node=node->next)
1323                 {
1324                   if(node->pkt->pkttype==PKT_USER_ID
1325                      && node->pkt->pkt.user_id->is_primary)
1326                     uid=node->pkt->pkt.user_id;
1327                   else if(node->pkt->pkttype==PKT_SIGNATURE
1328                           && node->pkt->pkt.signature->
1329                           flags.chosen_selfsig && uid)
1330                     {
1331                       sig=node->pkt->pkt.signature;
1332                       break;
1333                     }
1334                 }
1335
1336               /* Try and parse the keyserver URL.  If it doesn't work,
1337                  then we end up writing NULL which indicates we are
1338                  the same as any other key. */
1339               if(sig)
1340                 (*klist)[*count].skipfncvalue=parse_preferred_keyserver(sig);
1341             }
1342
1343           (*count)++;
1344
1345           if(*count==num)
1346             {
1347               num+=100;
1348               *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
1349             }
1350         }
1351     }
1352
1353   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1354     rc = 0;
1355
1356  leave:
1357   if(rc)
1358     {
1359       xfree(*klist);
1360       *klist = NULL;
1361     }
1362   xfree(desc);
1363   keydb_release(kdbhd);
1364   release_kbnode(keyblock);
1365
1366   return rc;
1367 }
1368
1369 /* Note this is different than the original HKP refresh.  It allows
1370    usernames to refresh only part of the keyring. */
1371
1372 gpg_error_t
1373 keyserver_refresh (ctrl_t ctrl, strlist_t users)
1374 {
1375   gpg_error_t err;
1376   int count, numdesc;
1377   int fakev3 = 0;
1378   KEYDB_SEARCH_DESC *desc;
1379   unsigned int options=opt.keyserver_options.import_options;
1380
1381   /* We switch merge-only on during a refresh, as 'refresh' should
1382      never import new keys, even if their keyids match. */
1383   opt.keyserver_options.import_options|=IMPORT_MERGE_ONLY;
1384
1385   /* Similarly, we switch on fast-import, since refresh may make
1386      multiple import sets (due to preferred keyserver URLs).  We don't
1387      want each set to rebuild the trustdb.  Instead we do it once at
1388      the end here. */
1389   opt.keyserver_options.import_options|=IMPORT_FAST;
1390
1391   /* If refresh_add_fake_v3_keyids is on and it's a HKP or MAILTO
1392      scheme, then enable fake v3 keyid generation.  Note that this
1393      works only with a keyserver configured. gpg.conf
1394      (i.e. opt.keyserver); however that method of configuring a
1395      keyserver is deprecated and in any case it is questionable
1396      whether we should keep on supporting these ancient and broken
1397      keyservers.  */
1398   if((opt.keyserver_options.options&KEYSERVER_ADD_FAKE_V3) && opt.keyserver
1399      && (ascii_strcasecmp(opt.keyserver->scheme,"hkp")==0 ||
1400          ascii_strcasecmp(opt.keyserver->scheme,"mailto")==0))
1401     fakev3=1;
1402
1403   err = keyidlist (users, &desc, &numdesc, fakev3);
1404   if (err)
1405     return err;
1406
1407   count=numdesc;
1408   if(count>0)
1409     {
1410       int i;
1411
1412       /* Try to handle preferred keyserver keys first */
1413       for(i=0;i<numdesc;i++)
1414         {
1415           if(desc[i].skipfncvalue)
1416             {
1417               struct keyserver_spec *keyserver=desc[i].skipfncvalue;
1418
1419               if (!opt.quiet)
1420                 log_info (_("refreshing %d key from %s\n"), 1, keyserver->uri);
1421
1422               /* We use the keyserver structure we parsed out before.
1423                  Note that a preferred keyserver without a scheme://
1424                  will be interpreted as hkp:// */
1425               err = keyserver_get (ctrl, &desc[i], 1, keyserver, NULL, NULL);
1426               if (err)
1427                 log_info(_("WARNING: unable to refresh key %s"
1428                            " via %s: %s\n"),keystr_from_desc(&desc[i]),
1429                          keyserver->uri,gpg_strerror (err));
1430               else
1431                 {
1432                   /* We got it, so mark it as NONE so we don't try and
1433                      get it again from the regular keyserver. */
1434
1435                   desc[i].mode=KEYDB_SEARCH_MODE_NONE;
1436                   count--;
1437                 }
1438
1439               free_keyserver_spec(keyserver);
1440             }
1441         }
1442     }
1443
1444   if(count>0)
1445     {
1446       char *tmpuri;
1447
1448       err = gpg_dirmngr_ks_list (ctrl, &tmpuri);
1449       if (!err)
1450         {
1451           if (!opt.quiet)
1452             {
1453               log_info (ngettext("refreshing %d key from %s\n",
1454                                  "refreshing %d keys from %s\n",
1455                                  count), count, tmpuri);
1456             }
1457           xfree (tmpuri);
1458
1459           err = keyserver_get (ctrl, desc, numdesc, NULL, NULL, NULL);
1460         }
1461     }
1462
1463   xfree(desc);
1464
1465   opt.keyserver_options.import_options=options;
1466
1467   /* If the original options didn't have fast import, and the trustdb
1468      is dirty, rebuild. */
1469   if(!(opt.keyserver_options.import_options&IMPORT_FAST))
1470     check_or_update_trustdb (ctrl);
1471
1472   return err;
1473 }
1474
1475
1476 /* Search for keys on the keyservers.  The patterns are given in the
1477    string list TOKENS.  */
1478 gpg_error_t
1479 keyserver_search (ctrl_t ctrl, strlist_t tokens)
1480 {
1481   gpg_error_t err;
1482   char *searchstr;
1483   struct search_line_handler_parm_s parm;
1484
1485   memset (&parm, 0, sizeof parm);
1486
1487   if (!tokens)
1488     return 0;  /* Return success if no patterns are given.  */
1489
1490   /* Write global options */
1491
1492   /* for(temp=opt.keyserver_options.other;temp;temp=temp->next) */
1493   /*   es_fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
1494
1495   /* Write per-keyserver options */
1496
1497   /* for(temp=keyserver->options;temp;temp=temp->next) */
1498   /*   es_fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
1499
1500   {
1501     membuf_t mb;
1502     strlist_t item;
1503
1504     init_membuf (&mb, 1024);
1505     for (item = tokens; item; item = item->next)
1506     {
1507       if (item != tokens)
1508         put_membuf (&mb, " ", 1);
1509       put_membuf_str (&mb, item->d);
1510     }
1511     put_membuf (&mb, "", 1); /* Append Nul.  */
1512     searchstr = get_membuf (&mb, NULL);
1513     if (!searchstr)
1514       {
1515         err = gpg_error_from_syserror ();
1516         goto leave;
1517       }
1518   }
1519   /* FIXME: Enable the next line */
1520   /* log_info (_("searching for \"%s\" from %s\n"), searchstr, keyserver->uri); */
1521
1522   parm.ctrl = ctrl;
1523   if (searchstr)
1524     parm.searchstr_disp = utf8_to_native (searchstr, strlen (searchstr), 0);
1525
1526   err = gpg_dirmngr_ks_search (ctrl, searchstr, search_line_handler, &parm);
1527
1528   if (parm.not_found)
1529     {
1530       if (parm.searchstr_disp)
1531         log_info (_("key \"%s\" not found on keyserver\n"),
1532                   parm.searchstr_disp);
1533       else
1534         log_info (_("key not found on keyserver\n"));
1535     }
1536
1537   if (gpg_err_code (err) == GPG_ERR_NO_KEYSERVER)
1538     log_error (_("no keyserver known (use option --keyserver)\n"));
1539   else if (err)
1540     log_error ("error searching keyserver: %s\n", gpg_strerror (err));
1541
1542   /* switch(ret) */
1543   /*   { */
1544   /*   case KEYSERVER_SCHEME_NOT_FOUND: */
1545   /*     log_error(_("no handler for keyserver scheme '%s'\n"), */
1546   /*        opt.keyserver->scheme); */
1547   /*     break; */
1548
1549   /*   case KEYSERVER_NOT_SUPPORTED: */
1550   /*     log_error(_("action '%s' not supported with keyserver " */
1551   /*          "scheme '%s'\n"), "search", opt.keyserver->scheme); */
1552   /*     break; */
1553
1554   /*   case KEYSERVER_TIMEOUT: */
1555   /*     log_error(_("keyserver timed out\n")); */
1556   /*     break; */
1557
1558   /*   case KEYSERVER_INTERNAL_ERROR: */
1559   /*   default: */
1560   /*     log_error(_("keyserver internal error\n")); */
1561   /*     break; */
1562   /*   } */
1563
1564   /* return gpg_error (GPG_ERR_KEYSERVER); */
1565
1566
1567  leave:
1568   xfree (parm.desc);
1569   xfree (parm.searchstr_disp);
1570   xfree(searchstr);
1571
1572   return err;
1573 }
1574
1575 /* Helper for keyserver_get.  Here we only receive a chunk of the
1576    description to be processed in one batch.  This is required due to
1577    the limited number of patterns the dirmngr interface (KS_GET) can
1578    grok and to limit the amount of temporary required memory.  */
1579 static gpg_error_t
1580 keyserver_get_chunk (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
1581                      int *r_ndesc_used,
1582                      import_stats_t stats_handle,
1583                      struct keyserver_spec *override_keyserver,
1584                      unsigned char **r_fpr, size_t *r_fprlen)
1585
1586 {
1587   gpg_error_t err = 0;
1588   char **pattern;
1589   int idx, npat;
1590   estream_t datastream;
1591   char *source = NULL;
1592   size_t linelen;  /* Estimated linelen for KS_GET.  */
1593   size_t n;
1594
1595 #define MAX_KS_GET_LINELEN 950  /* Somewhat lower than the real limit.  */
1596
1597   *r_ndesc_used = 0;
1598
1599   /* Create an array filled with a search pattern for each key.  The
1600      array is delimited by a NULL entry.  */
1601   pattern = xtrycalloc (ndesc+1, sizeof *pattern);
1602   if (!pattern)
1603     return gpg_error_from_syserror ();
1604
1605   /* Note that we break the loop as soon as our estimation of the to
1606      be used line length reaches the limit.  But we do this only if we
1607      have processed at leas one search requests so that an overlong
1608      single request will be rejected only later by gpg_dirmngr_ks_get
1609      but we are sure that R_NDESC_USED has been updated.  This avoids
1610      a possible indefinite loop.  */
1611   linelen = 9; /* "KS_GET --" */
1612   for (npat=idx=0; idx < ndesc; idx++)
1613     {
1614       int quiet = 0;
1615
1616       if (desc[idx].mode == KEYDB_SEARCH_MODE_FPR20
1617           || desc[idx].mode == KEYDB_SEARCH_MODE_FPR16)
1618         {
1619           n = 1+2+2*20;
1620           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1621             break; /* Declare end of this chunk.  */
1622           linelen += n;
1623
1624           pattern[npat] = xtrymalloc (n);
1625           if (!pattern[npat])
1626             err = gpg_error_from_syserror ();
1627           else
1628             {
1629               strcpy (pattern[npat], "0x");
1630               bin2hex (desc[idx].u.fpr,
1631                        desc[idx].mode == KEYDB_SEARCH_MODE_FPR20? 20 : 16,
1632                        pattern[npat]+2);
1633               npat++;
1634             }
1635         }
1636       else if(desc[idx].mode == KEYDB_SEARCH_MODE_LONG_KID)
1637         {
1638           n = 1+2+16;
1639           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1640             break; /* Declare end of this chunk.  */
1641           linelen += n;
1642
1643           pattern[npat] = xtryasprintf ("0x%08lX%08lX",
1644                                         (ulong)desc[idx].u.kid[0],
1645                                         (ulong)desc[idx].u.kid[1]);
1646           if (!pattern[npat])
1647             err = gpg_error_from_syserror ();
1648           else
1649             npat++;
1650         }
1651       else if(desc[idx].mode == KEYDB_SEARCH_MODE_SHORT_KID)
1652         {
1653           n = 1+2+8;
1654           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1655             break; /* Declare end of this chunk.  */
1656           linelen += n;
1657
1658           pattern[npat] = xtryasprintf ("0x%08lX", (ulong)desc[idx].u.kid[1]);
1659           if (!pattern[npat])
1660             err = gpg_error_from_syserror ();
1661           else
1662             npat++;
1663         }
1664       else if(desc[idx].mode == KEYDB_SEARCH_MODE_EXACT)
1665         {
1666           /* The Dirmngr also uses classify_user_id to detect the type
1667              of the search string.  By adding the '=' prefix we force
1668              Dirmngr's KS_GET to consider this an exact search string.
1669              (In gpg 1.4 and gpg 2.0 the keyserver helpers used the
1670              KS_GETNAME command to indicate this.)  */
1671
1672           n = 1+1+strlen (desc[idx].u.name);
1673           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1674             break; /* Declare end of this chunk.  */
1675           linelen += n;
1676
1677           pattern[npat] = strconcat ("=", desc[idx].u.name, NULL);
1678           if (!pattern[npat])
1679             err = gpg_error_from_syserror ();
1680           else
1681             {
1682               npat++;
1683               quiet = 1;
1684             }
1685         }
1686       else if (desc[idx].mode == KEYDB_SEARCH_MODE_NONE)
1687         continue;
1688       else
1689         BUG();
1690
1691       if (err)
1692         {
1693           for (idx=0; idx < npat; idx++)
1694             xfree (pattern[idx]);
1695           xfree (pattern);
1696           return err;
1697         }
1698
1699       if (!quiet && override_keyserver)
1700         {
1701           if (override_keyserver->host)
1702             log_info (_("requesting key %s from %s server %s\n"),
1703                       keystr_from_desc (&desc[idx]),
1704                       override_keyserver->scheme, override_keyserver->host);
1705           else
1706             log_info (_("requesting key %s from %s\n"),
1707                       keystr_from_desc (&desc[idx]), override_keyserver->uri);
1708         }
1709     }
1710
1711   /* Remember now many of search items were considered.  Note that
1712      this is different from NPAT.  */
1713   *r_ndesc_used = idx;
1714
1715   err = gpg_dirmngr_ks_get (ctrl, pattern, override_keyserver,
1716                             &datastream, &source);
1717   for (idx=0; idx < npat; idx++)
1718     xfree (pattern[idx]);
1719   xfree (pattern);
1720   if (opt.verbose && source)
1721     log_info ("data source: %s\n", source);
1722
1723   if (!err)
1724     {
1725       struct ks_retrieval_screener_arg_s screenerarg;
1726
1727       /* FIXME: Check whether this comment should be moved to dirmngr.
1728
1729          Slurp up all the key data.  In the future, it might be nice
1730          to look for KEY foo OUTOFBAND and FAILED indicators.  It's
1731          harmless to ignore them, but ignoring them does make gpg
1732          complain about "no valid OpenPGP data found".  One way to do
1733          this could be to continue parsing this line-by-line and make
1734          a temp iobuf for each key.  Note that we don't allow the
1735          import of secret keys from a keyserver.  Keyservers should
1736          never accept or send them but we better protect against rogue
1737          keyservers. */
1738
1739       screenerarg.desc = desc;
1740       screenerarg.ndesc = *r_ndesc_used;
1741       import_keys_es_stream (ctrl, datastream, stats_handle,
1742                              r_fpr, r_fprlen,
1743                              (opt.keyserver_options.import_options
1744                               | IMPORT_NO_SECKEY),
1745                              keyserver_retrieval_screener, &screenerarg);
1746     }
1747   es_fclose (datastream);
1748   xfree (source);
1749
1750   return err;
1751 }
1752
1753
1754 /* Retrieve a key from a keyserver.  The search pattern are in
1755    (DESC,NDESC).  Allowed search modes are keyid, fingerprint, and
1756    exact searches.  OVERRIDE_KEYSERVER gives an optional override
1757    keyserver. If (R_FPR,R_FPRLEN) are not NULL, they may return the
1758    fingerprint of a single imported key.  */
1759 static gpg_error_t
1760 keyserver_get (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
1761                struct keyserver_spec *override_keyserver,
1762                unsigned char **r_fpr, size_t *r_fprlen)
1763 {
1764   gpg_error_t err;
1765   import_stats_t stats_handle;
1766   int ndesc_used;
1767   int any_good = 0;
1768
1769   stats_handle = import_new_stats_handle();
1770
1771   for (;;)
1772     {
1773       err = keyserver_get_chunk (ctrl, desc, ndesc, &ndesc_used, stats_handle,
1774                                  override_keyserver, r_fpr, r_fprlen);
1775       if (!err)
1776         any_good = 1;
1777       if (err || ndesc_used >= ndesc)
1778         break; /* Error or all processed.  */
1779       /* Prepare for the next chunk.  */
1780       desc += ndesc_used;
1781       ndesc -= ndesc_used;
1782     }
1783
1784   if (any_good)
1785     import_print_stats (stats_handle);
1786
1787   import_release_stats_handle (stats_handle);
1788   return err;
1789 }
1790
1791
1792 /* Send all keys specified by KEYSPECS to the configured keyserver.  */
1793 static gpg_error_t
1794 keyserver_put (ctrl_t ctrl, strlist_t keyspecs)
1795
1796 {
1797   gpg_error_t err;
1798   strlist_t kspec;
1799   char *ksurl;
1800
1801   if (!keyspecs)
1802     return 0;  /* Return success if the list is empty.  */
1803
1804   if (gpg_dirmngr_ks_list (ctrl, &ksurl))
1805     {
1806       log_error (_("no keyserver known\n"));
1807       return gpg_error (GPG_ERR_NO_KEYSERVER);
1808     }
1809
1810   for (kspec = keyspecs; kspec; kspec = kspec->next)
1811     {
1812       void *data;
1813       size_t datalen;
1814       kbnode_t keyblock;
1815
1816       err = export_pubkey_buffer (ctrl, kspec->d,
1817                                   opt.keyserver_options.export_options,
1818                                   NULL,
1819                                   &keyblock, &data, &datalen);
1820       if (err)
1821         log_error (_("skipped \"%s\": %s\n"), kspec->d, gpg_strerror (err));
1822       else
1823         {
1824           log_info (_("sending key %s to %s\n"),
1825                     keystr (keyblock->pkt->pkt.public_key->keyid),
1826                     ksurl?ksurl:"[?]");
1827
1828           err = gpg_dirmngr_ks_put (ctrl, data, datalen, keyblock);
1829           release_kbnode (keyblock);
1830           xfree (data);
1831           if (err)
1832             {
1833               write_status_error ("keyserver_send", err);
1834               log_error (_("keyserver send failed: %s\n"), gpg_strerror (err));
1835             }
1836         }
1837     }
1838
1839   xfree (ksurl);
1840
1841   return err;
1842
1843 }
1844
1845
1846 /* Loop over all URLs in STRLIST and fetch the key at that URL.  Note
1847    that the fetch operation ignores the configured keyservers and
1848    instead directly retrieves the keys.  */
1849 int
1850 keyserver_fetch (ctrl_t ctrl, strlist_t urilist)
1851 {
1852   gpg_error_t err;
1853   strlist_t sl;
1854   estream_t datastream;
1855   unsigned int save_options = opt.keyserver_options.import_options;
1856
1857   /* Switch on fast-import, since fetch can handle more than one
1858      import and we don't want each set to rebuild the trustdb.
1859      Instead we do it once at the end. */
1860   opt.keyserver_options.import_options |= IMPORT_FAST;
1861
1862   for (sl=urilist; sl; sl=sl->next)
1863     {
1864       if (!opt.quiet)
1865         log_info (_("requesting key from '%s'\n"), sl->d);
1866
1867       err = gpg_dirmngr_ks_fetch (ctrl, sl->d, &datastream);
1868       if (!err)
1869         {
1870           import_stats_t stats_handle;
1871
1872           stats_handle = import_new_stats_handle();
1873           import_keys_es_stream (ctrl, datastream, stats_handle, NULL, NULL,
1874                                  opt.keyserver_options.import_options,
1875                                  NULL, NULL);
1876
1877           import_print_stats (stats_handle);
1878           import_release_stats_handle (stats_handle);
1879         }
1880       else
1881         log_info (_("WARNING: unable to fetch URI %s: %s\n"),
1882                   sl->d, gpg_strerror (err));
1883       es_fclose (datastream);
1884     }
1885
1886   opt.keyserver_options.import_options = save_options;
1887
1888   /* If the original options didn't have fast import, and the trustdb
1889      is dirty, rebuild. */
1890   if (!(opt.keyserver_options.import_options&IMPORT_FAST))
1891     check_or_update_trustdb (ctrl);
1892
1893   return 0;
1894 }
1895
1896
1897 /* Import key in a CERT or pointed to by a CERT.  In DANE_MODE fetch
1898    the certificate using the DANE method.  */
1899 int
1900 keyserver_import_cert (ctrl_t ctrl, const char *name, int dane_mode,
1901                        unsigned char **fpr,size_t *fpr_len)
1902 {
1903   gpg_error_t err;
1904   char *look,*url;
1905   estream_t key;
1906
1907   look = xstrdup(name);
1908
1909   if (!dane_mode)
1910     {
1911       char *domain = strrchr (look,'@');
1912       if (domain)
1913         *domain='.';
1914     }
1915
1916   err = gpg_dirmngr_dns_cert (ctrl, look, dane_mode? NULL : "*",
1917                               &key, fpr, fpr_len, &url);
1918   if (err)
1919     ;
1920   else if (key)
1921     {
1922       int armor_status=opt.no_armor;
1923
1924       /* CERTs and DANE records are always in binary format */
1925       opt.no_armor=1;
1926
1927       err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
1928                                    (opt.keyserver_options.import_options
1929                                     | IMPORT_NO_SECKEY),
1930                                    NULL, NULL);
1931
1932       opt.no_armor=armor_status;
1933
1934       es_fclose (key);
1935       key = NULL;
1936     }
1937   else if (*fpr)
1938     {
1939       /* We only consider the IPGP type if a fingerprint was provided.
1940          This lets us select the right key regardless of what a URL
1941          points to, or get the key from a keyserver. */
1942       if(url)
1943         {
1944           struct keyserver_spec *spec;
1945
1946           spec = parse_keyserver_uri (url, 1);
1947           if(spec)
1948             {
1949               err = keyserver_import_fprint (ctrl, *fpr,*fpr_len,spec);
1950               free_keyserver_spec(spec);
1951             }
1952         }
1953       else if (keyserver_any_configured (ctrl))
1954         {
1955           /* If only a fingerprint is provided, try and fetch it from
1956              the configured keyserver. */
1957
1958           err = keyserver_import_fprint (ctrl, *fpr,*fpr_len,opt.keyserver);
1959         }
1960       else
1961         log_info(_("no keyserver known\n"));
1962
1963       /* Give a better string here? "CERT fingerprint for \"%s\"
1964          found, but no keyserver" " known (use option
1965          --keyserver)\n" ? */
1966
1967     }
1968
1969   xfree(url);
1970   xfree(look);
1971
1972   return err;
1973 }
1974
1975 /* Import key pointed to by a PKA record. Return the requested
1976    fingerprint in fpr. */
1977 gpg_error_t
1978 keyserver_import_pka (ctrl_t ctrl, const char *name,
1979                       unsigned char **fpr, size_t *fpr_len)
1980 {
1981   gpg_error_t err;
1982   char *url;
1983
1984   err = gpg_dirmngr_get_pka (ctrl, name, fpr, fpr_len, &url);
1985   if (url && *url && fpr && fpr_len)
1986     {
1987       /* An URL is available.  Lookup the key. */
1988       struct keyserver_spec *spec;
1989       spec = parse_keyserver_uri (url, 1);
1990       if (spec)
1991         {
1992           err = keyserver_import_fprint (ctrl, *fpr, *fpr_len, spec);
1993           free_keyserver_spec (spec);
1994         }
1995     }
1996   xfree (url);
1997
1998   if (err)
1999     {
2000       xfree(*fpr);
2001       *fpr = NULL;
2002       *fpr_len = 0;
2003     }
2004
2005   return err;
2006 }
2007
2008
2009 /* Import a key using the Web Key Directory protocol.  */
2010 gpg_error_t
2011 keyserver_import_wkd (ctrl_t ctrl, const char *name,
2012                       unsigned char **fpr, size_t *fpr_len)
2013 {
2014   gpg_error_t err;
2015   char *mbox;
2016   estream_t key;
2017
2018   /* We want to work on the mbox.  That is what dirmngr will do anyway
2019    * and we need the mbox for the import filter anyway.  */
2020   mbox = mailbox_from_userid (name);
2021   if (!mbox)
2022     {
2023       err = gpg_error_from_syserror ();
2024       if (gpg_err_code (err) == GPG_ERR_EINVAL)
2025         err = gpg_error (GPG_ERR_INV_USER_ID);
2026       return err;
2027     }
2028
2029   err = gpg_dirmngr_wkd_get (ctrl, mbox, &key);
2030   if (err)
2031     ;
2032   else if (key)
2033     {
2034       int armor_status = opt.no_armor;
2035       import_filter_t save_filt;
2036
2037       /* Keys returned via WKD are in binary format. */
2038       opt.no_armor = 1;
2039       save_filt = save_and_clear_import_filter ();
2040       if (!save_filt)
2041         err = gpg_error_from_syserror ();
2042       else
2043         {
2044           char *filtstr = es_bsprintf ("keep-uid=mbox = %s", mbox);
2045           err = filtstr? 0 : gpg_error_from_syserror ();
2046           if (!err)
2047             err = parse_and_set_import_filter (filtstr);
2048           xfree (filtstr);
2049           if (!err)
2050             err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
2051                                          IMPORT_NO_SECKEY,
2052                                          NULL, NULL);
2053
2054         }
2055
2056       restore_import_filter (save_filt);
2057       opt.no_armor = armor_status;
2058
2059       es_fclose (key);
2060       key = NULL;
2061     }
2062
2063   xfree (mbox);
2064   return err;
2065 }
2066
2067
2068 /* Import a key by name using LDAP */
2069 int
2070 keyserver_import_ldap (ctrl_t ctrl,
2071                        const char *name, unsigned char **fpr, size_t *fprlen)
2072 {
2073   (void)ctrl;
2074   (void)name;
2075   (void)fpr;
2076   (void)fprlen;
2077   return gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
2078 #if 0
2079   char *domain;
2080   struct keyserver_spec *keyserver;
2081   strlist_t list=NULL;
2082   int rc,hostlen=1;
2083 #ifdef USE_DNS_SRV
2084   struct srventry *srvlist=NULL;
2085   int srvcount,i;
2086   char srvname[MAXDNAME];
2087 #endif
2088
2089   /* Parse out the domain */
2090   domain=strrchr(name,'@');
2091   if(!domain)
2092     return GPG_ERR_GENERAL;
2093
2094   domain++;
2095
2096   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
2097   keyserver->scheme=xstrdup("ldap");
2098   keyserver->host=xmalloc(1);
2099   keyserver->host[0]='\0';
2100
2101 #ifdef USE_DNS_SRV
2102   snprintf(srvname,MAXDNAME,"_pgpkey-ldap._tcp.%s",domain);
2103
2104   FIXME("network related - move to dirmngr or drop the code");
2105   srvcount=getsrv(srvname,&srvlist);
2106
2107   for(i=0;i<srvcount;i++)
2108     {
2109       hostlen+=strlen(srvlist[i].target)+1;
2110       keyserver->host=xrealloc(keyserver->host,hostlen);
2111
2112       strcat(keyserver->host,srvlist[i].target);
2113
2114       if(srvlist[i].port!=389)
2115         {
2116           char port[7];
2117
2118           hostlen+=6; /* a colon, plus 5 digits (unsigned 16-bit value) */
2119           keyserver->host=xrealloc(keyserver->host,hostlen);
2120
2121           snprintf(port,7,":%u",srvlist[i].port);
2122           strcat(keyserver->host,port);
2123         }
2124
2125       strcat(keyserver->host," ");
2126     }
2127
2128   free(srvlist);
2129 #endif
2130
2131   /* If all else fails, do the PGP Universal trick of
2132      ldap://keys.(domain) */
2133
2134   hostlen+=5+strlen(domain);
2135   keyserver->host=xrealloc(keyserver->host,hostlen);
2136   strcat(keyserver->host,"keys.");
2137   strcat(keyserver->host,domain);
2138
2139   append_to_strlist(&list,name);
2140
2141   rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
2142        /* keyserver_work (ctrl, KS_GETNAME, list, NULL, */
2143        /*                 0, fpr, fpr_len, keyserver); */
2144
2145   free_strlist(list);
2146
2147   free_keyserver_spec(keyserver);
2148
2149   return rc;
2150 #endif
2151 }