gpg: Auto-create revocation certificates.
[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 conatins 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       log_debug ("%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 int
1046 keyserver_import (ctrl_t ctrl, strlist_t users)
1047 {
1048   gpg_error_t err;
1049   KEYDB_SEARCH_DESC *desc;
1050   int num=100,count=0;
1051   int rc=0;
1052
1053   /* Build a list of key ids */
1054   desc=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
1055
1056   for(;users;users=users->next)
1057     {
1058       err = classify_user_id (users->d, &desc[count], 1);
1059       if (err || (desc[count].mode    != KEYDB_SEARCH_MODE_SHORT_KID
1060                   && desc[count].mode != KEYDB_SEARCH_MODE_LONG_KID
1061                   && desc[count].mode != KEYDB_SEARCH_MODE_FPR16
1062                   && desc[count].mode != KEYDB_SEARCH_MODE_FPR20))
1063         {
1064           log_error (_("\"%s\" not a key ID: skipping\n"), users->d);
1065           continue;
1066         }
1067
1068       count++;
1069       if(count==num)
1070         {
1071           num+=100;
1072           desc=xrealloc(desc,sizeof(KEYDB_SEARCH_DESC)*num);
1073         }
1074     }
1075
1076   if(count>0)
1077     rc=keyserver_get (ctrl, desc, count, NULL, NULL, NULL);
1078
1079   xfree(desc);
1080
1081   return rc;
1082 }
1083
1084
1085 /* Import all keys that exactly match NAME */
1086 int
1087 keyserver_import_name (ctrl_t ctrl, const char *name,
1088                        unsigned char **fpr, size_t *fprlen,
1089                        struct keyserver_spec *keyserver)
1090 {
1091   KEYDB_SEARCH_DESC desc;
1092
1093   memset (&desc, 0, sizeof desc);
1094
1095   desc.mode = KEYDB_SEARCH_MODE_EXACT;
1096   desc.u.name = name;
1097
1098   return keyserver_get (ctrl, &desc, 1, keyserver, fpr, fprlen);
1099 }
1100
1101
1102 int
1103 keyserver_import_fprint (ctrl_t ctrl, const byte *fprint,size_t fprint_len,
1104                          struct keyserver_spec *keyserver)
1105 {
1106   KEYDB_SEARCH_DESC desc;
1107
1108   memset(&desc,0,sizeof(desc));
1109
1110   if(fprint_len==16)
1111     desc.mode=KEYDB_SEARCH_MODE_FPR16;
1112   else if(fprint_len==20)
1113     desc.mode=KEYDB_SEARCH_MODE_FPR20;
1114   else
1115     return -1;
1116
1117   memcpy(desc.u.fpr,fprint,fprint_len);
1118
1119   /* TODO: Warn here if the fingerprint we got doesn't match the one
1120      we asked for? */
1121   return keyserver_get (ctrl, &desc, 1, keyserver, NULL, NULL);
1122 }
1123
1124 int
1125 keyserver_import_keyid (ctrl_t ctrl,
1126                         u32 *keyid,struct keyserver_spec *keyserver)
1127 {
1128   KEYDB_SEARCH_DESC desc;
1129
1130   memset(&desc,0,sizeof(desc));
1131
1132   desc.mode=KEYDB_SEARCH_MODE_LONG_KID;
1133   desc.u.kid[0]=keyid[0];
1134   desc.u.kid[1]=keyid[1];
1135
1136   return keyserver_get (ctrl, &desc,1, keyserver, NULL, NULL);
1137 }
1138
1139 /* code mostly stolen from do_export_stream */
1140 static int
1141 keyidlist(strlist_t users,KEYDB_SEARCH_DESC **klist,int *count,int fakev3)
1142 {
1143   int rc=0,ndesc,num=100;
1144   KBNODE keyblock=NULL,node;
1145   KEYDB_HANDLE kdbhd;
1146   KEYDB_SEARCH_DESC *desc;
1147   strlist_t sl;
1148
1149   *count=0;
1150
1151   *klist=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
1152
1153   kdbhd=keydb_new ();
1154
1155   if(!users)
1156     {
1157       ndesc = 1;
1158       desc = xmalloc_clear ( ndesc * sizeof *desc);
1159       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1160     }
1161   else
1162     {
1163       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
1164         ;
1165       desc = xmalloc ( ndesc * sizeof *desc);
1166
1167       for (ndesc=0, sl=users; sl; sl = sl->next)
1168         {
1169           gpg_error_t err;
1170           if (!(err = classify_user_id (sl->d, desc+ndesc, 1)))
1171             ndesc++;
1172           else
1173             log_error (_("key \"%s\" not found: %s\n"),
1174                        sl->d, gpg_strerror (err));
1175         }
1176     }
1177
1178   while (!(rc = keydb_search (kdbhd, desc, ndesc, NULL)))
1179     {
1180       if (!users)
1181         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1182
1183       /* read the keyblock */
1184       rc = keydb_get_keyblock (kdbhd, &keyblock );
1185       if( rc )
1186         {
1187           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
1188           goto leave;
1189         }
1190
1191       if((node=find_kbnode(keyblock,PKT_PUBLIC_KEY)))
1192         {
1193           /* This is to work around a bug in some keyservers (pksd and
1194              OKS) that calculate v4 RSA keyids as if they were v3 RSA.
1195              The answer is to refresh both the correct v4 keyid
1196              (e.g. 99242560) and the fake v3 keyid (e.g. 68FDDBC7).
1197              This only happens for key refresh using the HKP scheme
1198              and if the refresh-add-fake-v3-keyids keyserver option is
1199              set. */
1200           if(fakev3 && is_RSA(node->pkt->pkt.public_key->pubkey_algo) &&
1201              node->pkt->pkt.public_key->version>=4)
1202             {
1203               (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
1204               v3_keyid (node->pkt->pkt.public_key->pkey[0],
1205                         (*klist)[*count].u.kid);
1206               (*count)++;
1207
1208               if(*count==num)
1209                 {
1210                   num+=100;
1211                   *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
1212                 }
1213             }
1214
1215           /* v4 keys get full fingerprints.  v3 keys get long keyids.
1216              This is because it's easy to calculate any sort of keyid
1217              from a v4 fingerprint, but not a v3 fingerprint. */
1218
1219           if(node->pkt->pkt.public_key->version<4)
1220             {
1221               (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
1222               keyid_from_pk(node->pkt->pkt.public_key,
1223                             (*klist)[*count].u.kid);
1224             }
1225           else
1226             {
1227               size_t dummy;
1228
1229               (*klist)[*count].mode=KEYDB_SEARCH_MODE_FPR20;
1230               fingerprint_from_pk(node->pkt->pkt.public_key,
1231                                   (*klist)[*count].u.fpr,&dummy);
1232             }
1233
1234           /* This is a little hackish, using the skipfncvalue as a
1235              void* pointer to the keyserver spec, but we don't need
1236              the skipfnc here, and it saves having an additional field
1237              for this (which would be wasted space most of the
1238              time). */
1239
1240           (*klist)[*count].skipfncvalue=NULL;
1241
1242           /* Are we honoring preferred keyservers? */
1243           if(opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1244             {
1245               PKT_user_id *uid=NULL;
1246               PKT_signature *sig=NULL;
1247
1248               merge_keys_and_selfsig(keyblock);
1249
1250               for(node=node->next;node;node=node->next)
1251                 {
1252                   if(node->pkt->pkttype==PKT_USER_ID
1253                      && node->pkt->pkt.user_id->is_primary)
1254                     uid=node->pkt->pkt.user_id;
1255                   else if(node->pkt->pkttype==PKT_SIGNATURE
1256                           && node->pkt->pkt.signature->
1257                           flags.chosen_selfsig && uid)
1258                     {
1259                       sig=node->pkt->pkt.signature;
1260                       break;
1261                     }
1262                 }
1263
1264               /* Try and parse the keyserver URL.  If it doesn't work,
1265                  then we end up writing NULL which indicates we are
1266                  the same as any other key. */
1267               if(sig)
1268                 (*klist)[*count].skipfncvalue=parse_preferred_keyserver(sig);
1269             }
1270
1271           (*count)++;
1272
1273           if(*count==num)
1274             {
1275               num+=100;
1276               *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
1277             }
1278         }
1279     }
1280
1281   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1282     rc = 0;
1283
1284  leave:
1285   if(rc)
1286     xfree(*klist);
1287   xfree(desc);
1288   keydb_release(kdbhd);
1289   release_kbnode(keyblock);
1290
1291   return rc;
1292 }
1293
1294 /* Note this is different than the original HKP refresh.  It allows
1295    usernames to refresh only part of the keyring. */
1296
1297 int
1298 keyserver_refresh (ctrl_t ctrl, strlist_t users)
1299 {
1300   int rc,count,numdesc,fakev3=0;
1301   KEYDB_SEARCH_DESC *desc;
1302   unsigned int options=opt.keyserver_options.import_options;
1303
1304   /* We switch merge-only on during a refresh, as 'refresh' should
1305      never import new keys, even if their keyids match. */
1306   opt.keyserver_options.import_options|=IMPORT_MERGE_ONLY;
1307
1308   /* Similarly, we switch on fast-import, since refresh may make
1309      multiple import sets (due to preferred keyserver URLs).  We don't
1310      want each set to rebuild the trustdb.  Instead we do it once at
1311      the end here. */
1312   opt.keyserver_options.import_options|=IMPORT_FAST;
1313
1314   /* If refresh_add_fake_v3_keyids is on and it's a HKP or MAILTO
1315      scheme, then enable fake v3 keyid generation. */
1316   if((opt.keyserver_options.options&KEYSERVER_ADD_FAKE_V3) && opt.keyserver
1317      && (ascii_strcasecmp(opt.keyserver->scheme,"hkp")==0 ||
1318          ascii_strcasecmp(opt.keyserver->scheme,"mailto")==0))
1319     fakev3=1;
1320
1321   rc=keyidlist(users,&desc,&numdesc,fakev3);
1322   if(rc)
1323     return rc;
1324
1325   count=numdesc;
1326   if(count>0)
1327     {
1328       int i;
1329
1330       /* Try to handle preferred keyserver keys first */
1331       for(i=0;i<numdesc;i++)
1332         {
1333           if(desc[i].skipfncvalue)
1334             {
1335               struct keyserver_spec *keyserver=desc[i].skipfncvalue;
1336
1337               /* We use the keyserver structure we parsed out before.
1338                  Note that a preferred keyserver without a scheme://
1339                  will be interpreted as hkp:// */
1340               rc = keyserver_get (ctrl, &desc[i], 1, keyserver, NULL, NULL);
1341               if(rc)
1342                 log_info(_("WARNING: unable to refresh key %s"
1343                            " via %s: %s\n"),keystr_from_desc(&desc[i]),
1344                          keyserver->uri,g10_errstr(rc));
1345               else
1346                 {
1347                   /* We got it, so mark it as NONE so we don't try and
1348                      get it again from the regular keyserver. */
1349
1350                   desc[i].mode=KEYDB_SEARCH_MODE_NONE;
1351                   count--;
1352                 }
1353
1354               free_keyserver_spec(keyserver);
1355             }
1356         }
1357     }
1358
1359   if(count>0)
1360     {
1361       if(opt.keyserver)
1362         {
1363           if(count==1)
1364             log_info(_("refreshing 1 key from %s\n"),opt.keyserver->uri);
1365           else
1366             log_info(_("refreshing %d keys from %s\n"),
1367                      count,opt.keyserver->uri);
1368         }
1369
1370       rc=keyserver_get (ctrl, desc, numdesc, NULL, NULL, NULL);
1371     }
1372
1373   xfree(desc);
1374
1375   opt.keyserver_options.import_options=options;
1376
1377   /* If the original options didn't have fast import, and the trustdb
1378      is dirty, rebuild. */
1379   if(!(opt.keyserver_options.import_options&IMPORT_FAST))
1380     check_or_update_trustdb ();
1381
1382   return rc;
1383 }
1384
1385
1386 /* Search for keys on the keyservers.  The patterns are given in the
1387    string list TOKENS.  */
1388 gpg_error_t
1389 keyserver_search (ctrl_t ctrl, strlist_t tokens)
1390 {
1391   gpg_error_t err;
1392   char *searchstr;
1393   struct search_line_handler_parm_s parm;
1394
1395   memset (&parm, 0, sizeof parm);
1396
1397   if (!tokens)
1398     return 0;  /* Return success if no patterns are given.  */
1399
1400   if (!opt.keyserver)
1401     {
1402       log_error (_("no keyserver known (use option --keyserver)\n"));
1403       return gpg_error (GPG_ERR_NO_KEYSERVER);
1404     }
1405
1406   /* Write global options */
1407
1408   /* for(temp=opt.keyserver_options.other;temp;temp=temp->next) */
1409   /*   fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
1410
1411   /* Write per-keyserver options */
1412
1413   /* for(temp=keyserver->options;temp;temp=temp->next) */
1414   /*   fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
1415
1416   {
1417     membuf_t mb;
1418     strlist_t item;
1419
1420     init_membuf (&mb, 1024);
1421     for (item = tokens; item; item = item->next)
1422     {
1423       if (item != tokens)
1424         put_membuf (&mb, " ", 1);
1425       put_membuf_str (&mb, item->d);
1426     }
1427     put_membuf (&mb, "", 1); /* Append Nul.  */
1428     searchstr = get_membuf (&mb, NULL);
1429     if (!searchstr)
1430       {
1431         err = gpg_error_from_syserror ();
1432         goto leave;
1433       }
1434   }
1435   /* FIXME: Enable the next line */
1436   /* log_info (_("searching for \"%s\" from %s\n"), searchstr, keyserver->uri); */
1437
1438   parm.ctrl = ctrl;
1439   if (searchstr)
1440     parm.searchstr_disp = utf8_to_native (searchstr, strlen (searchstr), 0);
1441
1442   err = gpg_dirmngr_ks_search (ctrl, searchstr, search_line_handler, &parm);
1443
1444   if (parm.not_found)
1445     {
1446       if (parm.searchstr_disp)
1447         log_info (_("key \"%s\" not found on keyserver\n"),
1448                   parm.searchstr_disp);
1449       else
1450         log_info (_("key not found on keyserver\n"));
1451     }
1452
1453   if (gpg_err_code (err) == GPG_ERR_NO_KEYSERVER)
1454     log_error (_("no keyserver known (use option --keyserver)\n"));
1455   else if (err)
1456     log_error ("error searching keyserver: %s\n", gpg_strerror (err));
1457
1458   /* switch(ret) */
1459   /*   { */
1460   /*   case KEYSERVER_SCHEME_NOT_FOUND: */
1461   /*     log_error(_("no handler for keyserver scheme '%s'\n"), */
1462   /*        opt.keyserver->scheme); */
1463   /*     break; */
1464
1465   /*   case KEYSERVER_NOT_SUPPORTED: */
1466   /*     log_error(_("action '%s' not supported with keyserver " */
1467   /*          "scheme '%s'\n"), "search", opt.keyserver->scheme); */
1468   /*     break; */
1469
1470   /*   case KEYSERVER_TIMEOUT: */
1471   /*     log_error(_("keyserver timed out\n")); */
1472   /*     break; */
1473
1474   /*   case KEYSERVER_INTERNAL_ERROR: */
1475   /*   default: */
1476   /*     log_error(_("keyserver internal error\n")); */
1477   /*     break; */
1478   /*   } */
1479
1480   /* return gpg_error (GPG_ERR_KEYSERVER); */
1481
1482
1483  leave:
1484   xfree (parm.desc);
1485   xfree (parm.searchstr_disp);
1486   xfree(searchstr);
1487
1488   return err;
1489 }
1490
1491
1492
1493 /* Retrieve a key from a keyserver.  The search pattern are in
1494    (DESC,NDESC).  Allowed search modes are keyid, fingerprint, and
1495    exact searches.  KEYSERVER gives an optional override keyserver. If
1496    (R_FPR,R_FPRLEN) are not NULL, the may retrun the fingerprint of
1497    one imported key.  */
1498 static gpg_error_t
1499 keyserver_get (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
1500                struct keyserver_spec *keyserver,
1501                unsigned char **r_fpr, size_t *r_fprlen)
1502
1503 {
1504   gpg_error_t err = 0;
1505   char **pattern;
1506   int idx, npat;
1507   estream_t datastream;
1508   char *source = NULL;
1509
1510   /* Create an array filled with a search pattern for each key.  The
1511      array is delimited by a NULL entry.  */
1512   pattern = xtrycalloc (ndesc+1, sizeof *pattern);
1513   if (!pattern)
1514     return gpg_error_from_syserror ();
1515   for (npat=idx=0; idx < ndesc; idx++)
1516     {
1517       int quiet = 0;
1518
1519       if (desc[idx].mode == KEYDB_SEARCH_MODE_FPR20
1520           || desc[idx].mode == KEYDB_SEARCH_MODE_FPR16)
1521         {
1522           pattern[npat] = xtrymalloc (2+2*20+1);
1523           if (!pattern[npat])
1524             err = gpg_error_from_syserror ();
1525           else
1526             {
1527               strcpy (pattern[npat], "0x");
1528               bin2hex (desc[idx].u.fpr,
1529                        desc[idx].mode == KEYDB_SEARCH_MODE_FPR20? 20 : 16,
1530                        pattern[npat]+2);
1531               npat++;
1532             }
1533         }
1534       else if(desc[idx].mode == KEYDB_SEARCH_MODE_LONG_KID)
1535         {
1536           pattern[npat] = xtryasprintf ("0x%08lX%08lX",
1537                                         (ulong)desc[idx].u.kid[0],
1538                                         (ulong)desc[idx].u.kid[1]);
1539           if (!pattern[npat])
1540             err = gpg_error_from_syserror ();
1541           else
1542             npat++;
1543         }
1544       else if(desc[idx].mode == KEYDB_SEARCH_MODE_SHORT_KID)
1545         {
1546           pattern[npat] = xtryasprintf ("0x%08lX", (ulong)desc[idx].u.kid[1]);
1547           if (!pattern[npat])
1548             err = gpg_error_from_syserror ();
1549           else
1550             npat++;
1551         }
1552       else if(desc[idx].mode == KEYDB_SEARCH_MODE_EXACT)
1553         {
1554           /* The Dirmngr uses also classify_user_id to detect the type
1555              of the search string.  By adding the '=' prefix we force
1556              Dirmngr's KS_GET to consider this an exact search string.
1557              (In gpg 1.4 and gpg 2.0 the keyserver helpers used the
1558              KS_GETNAME command to indicate this.)  */
1559           pattern[npat] = strconcat ("=", desc[idx].u.name, NULL);
1560           if (!pattern[npat])
1561             err = gpg_error_from_syserror ();
1562           else
1563             {
1564               npat++;
1565               quiet = 1;
1566             }
1567         }
1568       else if (desc[idx].mode == KEYDB_SEARCH_MODE_NONE)
1569         continue;
1570       else
1571         BUG();
1572
1573       if (err)
1574         {
1575           for (idx=0; idx < npat; idx++)
1576             xfree (pattern[idx]);
1577           xfree (pattern);
1578           return err;
1579         }
1580
1581       if (!quiet && keyserver)
1582         {
1583           if (keyserver->host)
1584             log_info (_("requesting key %s from %s server %s\n"),
1585                       keystr_from_desc (&desc[idx]),
1586                       keyserver->scheme, keyserver->host);
1587           else
1588             log_info (_("requesting key %s from %s\n"),
1589                       keystr_from_desc (&desc[idx]), keyserver->uri);
1590         }
1591     }
1592
1593
1594   err = gpg_dirmngr_ks_get (ctrl, pattern, &datastream, &source);
1595   for (idx=0; idx < npat; idx++)
1596     xfree (pattern[idx]);
1597   xfree (pattern);
1598   if (opt.verbose && source)
1599     log_info ("data source: %s\n", source);
1600
1601   if (!err)
1602     {
1603       void *stats_handle;
1604
1605       stats_handle = import_new_stats_handle();
1606
1607       /* FIXME: Check whether this comment should be moved to dirmngr.
1608
1609          Slurp up all the key data.  In the future, it might be nice
1610          to look for KEY foo OUTOFBAND and FAILED indicators.  It's
1611          harmless to ignore them, but ignoring them does make gpg
1612          complain about "no valid OpenPGP data found".  One way to do
1613          this could be to continue parsing this line-by-line and make
1614          a temp iobuf for each key.  Note that we don't allow the
1615          import of secret keys from a keyserver.  Keyservers should
1616          never accept or send them but we better protect against rogue
1617          keyservers. */
1618
1619       import_keys_es_stream (ctrl, datastream, stats_handle,
1620                              r_fpr, r_fprlen,
1621                              (opt.keyserver_options.import_options
1622                               | IMPORT_NO_SECKEY));
1623       import_print_stats (stats_handle);
1624       import_release_stats_handle (stats_handle);
1625     }
1626   es_fclose (datastream);
1627   xfree (source);
1628
1629   return err;
1630 }
1631
1632
1633 /* Send all keys specified by KEYSPECS to the KEYSERVERS.  */
1634 static gpg_error_t
1635 keyserver_put (ctrl_t ctrl, strlist_t keyspecs,
1636                struct keyserver_spec *keyserver)
1637
1638 {
1639   gpg_error_t err;
1640   strlist_t kspec;
1641
1642   if (!keyspecs)
1643     return 0;  /* Return success if the list is empty.  */
1644
1645   if (!opt.keyserver)
1646     {
1647       log_error (_("no keyserver known (use option --keyserver)\n"));
1648       return gpg_error (GPG_ERR_NO_KEYSERVER);
1649     }
1650
1651   for (kspec = keyspecs; kspec; kspec = kspec->next)
1652     {
1653       void *data;
1654       size_t datalen;
1655       kbnode_t keyblock;
1656
1657       err = export_pubkey_buffer (ctrl, kspec->d,
1658                                   opt.keyserver_options.export_options,
1659                                   &keyblock, &data, &datalen);
1660       if (err)
1661         log_error (_("skipped \"%s\": %s\n"), kspec->d, gpg_strerror (err));
1662       else
1663         {
1664           if (keyserver->host)
1665             log_info (_("sending key %s to %s server %s\n"),
1666                       keystr (keyblock->pkt->pkt.public_key->keyid),
1667                       keyserver->scheme, keyserver->host);
1668           else
1669             log_info (_("sending key %s to %s\n"),
1670                       keystr (keyblock->pkt->pkt.public_key->keyid),
1671                       keyserver->uri);
1672
1673           err = gpg_dirmngr_ks_put (ctrl, data, datalen, keyblock);
1674           release_kbnode (keyblock);
1675           xfree (data);
1676           if (err)
1677             log_error (_("keyserver send failed: %s\n"), gpg_strerror (err));
1678         }
1679     }
1680
1681
1682   return err;
1683
1684 }
1685
1686
1687 /* Loop over all URLs in STRLIST and fetch the key that URL.  Note
1688    that the fetch operation ignores the configured key servers and
1689    instead directly retrieves the keys.  */
1690 int
1691 keyserver_fetch (ctrl_t ctrl, strlist_t urilist)
1692 {
1693   gpg_error_t err;
1694   strlist_t sl;
1695   estream_t datastream;
1696   unsigned int save_options = opt.keyserver_options.import_options;
1697
1698   /* Switch on fast-import, since fetch can handle more than one
1699      import and we don't want each set to rebuild the trustdb.
1700      Instead we do it once at the end. */
1701   opt.keyserver_options.import_options |= IMPORT_FAST;
1702
1703   for (sl=urilist; sl; sl=sl->next)
1704     {
1705       if (!opt.quiet)
1706         log_info (_("requesting key from '%s'\n"), sl->d);
1707
1708       err = gpg_dirmngr_ks_fetch (ctrl, sl->d, &datastream);
1709       if (!err)
1710         {
1711           void *stats_handle;
1712
1713           stats_handle = import_new_stats_handle();
1714           import_keys_es_stream (ctrl, datastream, stats_handle, NULL, NULL,
1715                                  opt.keyserver_options.import_options);
1716
1717           import_print_stats (stats_handle);
1718           import_release_stats_handle (stats_handle);
1719         }
1720       else
1721         log_info (_("WARNING: unable to fetch URI %s: %s\n"),
1722                   sl->d, gpg_strerror (err));
1723       es_fclose (datastream);
1724     }
1725
1726   opt.keyserver_options.import_options = save_options;
1727
1728   /* If the original options didn't have fast import, and the trustdb
1729      is dirty, rebuild. */
1730   if (!(opt.keyserver_options.import_options&IMPORT_FAST))
1731     check_or_update_trustdb ();
1732
1733   return 0;
1734 }
1735
1736
1737 /* Import key in a CERT or pointed to by a CERT */
1738 int
1739 keyserver_import_cert (ctrl_t ctrl,
1740                        const char *name,unsigned char **fpr,size_t *fpr_len)
1741 {
1742   gpg_error_t err;
1743   char *domain,*look,*url;
1744   estream_t key;
1745
1746
1747   look=xstrdup(name);
1748
1749   domain=strrchr(look,'@');
1750   if(domain)
1751     *domain='.';
1752
1753   err = get_dns_cert (look, &key, fpr, fpr_len, &url);
1754   if (err)
1755     ;
1756   else if (key)
1757     {
1758       int armor_status=opt.no_armor;
1759
1760       /* CERTs are always in binary format */
1761       opt.no_armor=1;
1762
1763       err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
1764                                    (opt.keyserver_options.import_options
1765                                     | IMPORT_NO_SECKEY));
1766
1767       opt.no_armor=armor_status;
1768
1769       es_fclose (key);
1770       key = NULL;
1771     }
1772   else if (*fpr)
1773     {
1774       /* We only consider the IPGP type if a fingerprint was provided.
1775          This lets us select the right key regardless of what a URL
1776          points to, or get the key from a keyserver. */
1777       if(url)
1778         {
1779           struct keyserver_spec *spec;
1780
1781           spec=parse_keyserver_uri(url,1,NULL,0);
1782           if(spec)
1783             {
1784               err = keyserver_import_fprint (ctrl, *fpr,*fpr_len,spec);
1785               free_keyserver_spec(spec);
1786             }
1787         }
1788       else if(opt.keyserver)
1789         {
1790           /* If only a fingerprint is provided, try and fetch it from
1791              our --keyserver */
1792
1793           err = keyserver_import_fprint (ctrl, *fpr,*fpr_len,opt.keyserver);
1794         }
1795       else
1796         log_info(_("no keyserver known (use option --keyserver)\n"));
1797
1798       /* Give a better string here? "CERT fingerprint for \"%s\"
1799          found, but no keyserver" " known (use option
1800          --keyserver)\n" ? */
1801
1802     }
1803
1804   xfree(url);
1805   xfree(look);
1806
1807   return err;
1808 }
1809
1810 /* Import key pointed to by a PKA record. Return the requested
1811    fingerprint in fpr. */
1812 int
1813 keyserver_import_pka (ctrl_t ctrl,
1814                       const char *name,unsigned char **fpr,size_t *fpr_len)
1815 {
1816   char *uri;
1817   int rc = G10ERR_NO_PUBKEY;
1818
1819   *fpr = xmalloc (20);
1820   *fpr_len = 20;
1821
1822   uri = get_pka_info (name, *fpr);
1823   if (uri && *uri)
1824     {
1825       /* An URI is available.  Lookup the key. */
1826       struct keyserver_spec *spec;
1827       spec = parse_keyserver_uri (uri, 1, NULL, 0);
1828       if (spec)
1829         {
1830           rc = keyserver_import_fprint (ctrl, *fpr, 20, spec);
1831           free_keyserver_spec (spec);
1832         }
1833       xfree (uri);
1834     }
1835
1836   if (rc)
1837     {
1838       xfree(*fpr);
1839       *fpr = NULL;
1840     }
1841
1842   return rc;
1843 }
1844
1845
1846 /* Import a key by name using LDAP */
1847 int
1848 keyserver_import_ldap (ctrl_t ctrl,
1849                        const char *name, unsigned char **fpr, size_t *fprlen)
1850 {
1851   (void)ctrl;
1852   (void)name;
1853   (void)fpr;
1854   (void)fprlen;
1855   return gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
1856 #if 0
1857   char *domain;
1858   struct keyserver_spec *keyserver;
1859   strlist_t list=NULL;
1860   int rc,hostlen=1;
1861 #ifdef USE_DNS_SRV
1862   struct srventry *srvlist=NULL;
1863   int srvcount,i;
1864   char srvname[MAXDNAME];
1865 #endif
1866
1867   /* Parse out the domain */
1868   domain=strrchr(name,'@');
1869   if(!domain)
1870     return G10ERR_GENERAL;
1871
1872   domain++;
1873
1874   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
1875   keyserver->scheme=xstrdup("ldap");
1876   keyserver->host=xmalloc(1);
1877   keyserver->host[0]='\0';
1878
1879 #ifdef USE_DNS_SRV
1880   snprintf(srvname,MAXDNAME,"_pgpkey-ldap._tcp.%s",domain);
1881
1882   srvcount=getsrv(srvname,&srvlist);
1883
1884   for(i=0;i<srvcount;i++)
1885     {
1886       hostlen+=strlen(srvlist[i].target)+1;
1887       keyserver->host=xrealloc(keyserver->host,hostlen);
1888
1889       strcat(keyserver->host,srvlist[i].target);
1890
1891       if(srvlist[i].port!=389)
1892         {
1893           char port[7];
1894
1895           hostlen+=6; /* a colon, plus 5 digits (unsigned 16-bit value) */
1896           keyserver->host=xrealloc(keyserver->host,hostlen);
1897
1898           snprintf(port,7,":%u",srvlist[i].port);
1899           strcat(keyserver->host,port);
1900         }
1901
1902       strcat(keyserver->host," ");
1903     }
1904
1905   free(srvlist);
1906 #endif
1907
1908   /* If all else fails, do the PGP Universal trick of
1909      ldap://keys.(domain) */
1910
1911   hostlen+=5+strlen(domain);
1912   keyserver->host=xrealloc(keyserver->host,hostlen);
1913   strcat(keyserver->host,"keys.");
1914   strcat(keyserver->host,domain);
1915
1916   append_to_strlist(&list,name);
1917
1918   rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
1919        /* keyserver_work (ctrl, KS_GETNAME, list, NULL, */
1920        /*                 0, fpr, fpr_len, keyserver); */
1921
1922   free_strlist(list);
1923
1924   free_keyserver_spec(keyserver);
1925
1926   return rc;
1927 #endif
1928 }