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