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