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