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