28b4a101093701c8144dd49afd8950ff43ed7585
[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.  LINE is the actual data line received with all
835    escaping removed and guaranteed to be exactly one line with
836    stripped LF; an EOF is indicated by LINE passed as NULL.  LINE may
837    be modified after return.  */
838 static gpg_error_t
839 search_line_handler (void *opaque, char *line)
840 {
841   struct search_line_handler_parm_s *parm = opaque;
842   gpg_error_t err = 0;
843   struct keyrec *keyrec;
844
845   if (parm->eof_seen && line)
846     {
847       log_debug ("ooops: unexpected data after EOF\n");
848       line = NULL;
849     }
850
851   /* Print the received line.  */
852   if (opt.with_colons && line)
853     {
854       log_debug ("%s\n",line);
855     }
856
857   /* Look for an info: line.  The only current info: values defined
858      are the version and key count. */
859   if (line && !parm->any_lines && !ascii_strncasecmp ("info:", line, 5))
860     {
861       char *str = line + 5;
862       char *tok;
863
864       if ((tok = strsep (&str, ":")))
865         {
866           int version;
867
868           if (sscanf (tok, "%d", &version) !=1 )
869             version = 1;
870
871           if (version !=1 )
872             {
873               log_error (_("invalid keyserver protocol "
874                            "(us %d!=handler %d)\n"), 1, version);
875               return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
876             }
877         }
878
879       if ((tok = strsep (&str, ":"))
880           && sscanf (tok, "%d", &parm->count) == 1)
881         {
882           if (!parm->count)
883             parm->not_found = 1;/* Server indicated that no items follow.  */
884           else if (parm->count < 0)
885             parm->count = 10;   /* Bad value - assume something reasonable.  */
886           else
887             parm->validcount = 1; /* COUNT seems to be okay.  */
888         }
889
890       parm->any_lines = 1;
891       return 0; /* Line processing finished.  */
892     }
893
894  again:
895   if (line)
896     keyrec = parse_keyrec (line);
897   else
898     {
899       /* Received EOF - flush data */
900       parm->eof_seen = 1;
901       keyrec = parse_keyrec (NULL);
902       if (!keyrec)
903         {
904           if (!parm->nkeys)
905             parm->not_found = 1;  /* No keys at all.  */
906           else
907             {
908               if (parm->nkeys != parm->count)
909                 parm->validcount = 0;
910
911               if (!(opt.with_colons && opt.batch))
912                 {
913                   err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
914                                      parm->validcount? parm->count : 0,
915                                      parm->searchstr_disp);
916                   return err;
917                 }
918             }
919         }
920     }
921
922   /* Save the key in the key array.  */
923   if (keyrec)
924     {
925       /* Allocate or enlarge the key array if needed.  */
926       if (!parm->desc)
927         {
928           if (parm->count < 1)
929             {
930               parm->count = 10;
931               parm->validcount = 0;
932             }
933           parm->desc = xtrymalloc (parm->count * sizeof *parm->desc);
934           if (!parm->desc)
935             {
936               err = gpg_error_from_syserror ();
937               iobuf_close (keyrec->uidbuf);
938               xfree (keyrec);
939               return err;
940             }
941         }
942       else if (parm->nkeys == parm->count)
943         {
944           /* Keyserver sent more keys than claimed in the info: line. */
945           KEYDB_SEARCH_DESC *tmp;
946           int newcount = parm->count + 10;
947
948           tmp = xtryrealloc (parm->desc, newcount * sizeof *parm->desc);
949           if (!tmp)
950             {
951               err = gpg_error_from_syserror ();
952               iobuf_close (keyrec->uidbuf);
953               xfree (keyrec);
954               return err;
955             }
956           parm->count = newcount;
957           parm->desc = tmp;
958           parm->validcount = 0;
959         }
960
961       parm->desc[parm->nkeys] = keyrec->desc;
962
963       if (!opt.with_colons)
964         {
965           /* SCREEN_LINES - 1 for the prompt. */
966           if (parm->numlines + keyrec->lines > opt.screen_lines - 1)
967             {
968               err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
969                                  parm->validcount ? parm->count:0,
970                                  parm->searchstr_disp);
971               if (err)
972                 return err;
973               parm->numlines = 0;
974             }
975
976           print_keyrec (parm->nkeys+1, keyrec);
977         }
978
979       parm->numlines += keyrec->lines;
980       iobuf_close (keyrec->uidbuf);
981       xfree (keyrec);
982
983       parm->any_lines = 1;
984       parm->nkeys++;
985
986       /* If we are here due to a flush after the EOF, run again for
987          the last prompt.  Fixme: Make this code better readable. */
988       if (parm->eof_seen)
989         goto again;
990     }
991
992   return 0;
993 }
994
995
996
997 int
998 keyserver_export (ctrl_t ctrl, strlist_t users)
999 {
1000   gpg_error_t err;
1001   strlist_t sl=NULL;
1002   KEYDB_SEARCH_DESC desc;
1003   int rc=0;
1004
1005   /* Weed out descriptors that we don't support sending */
1006   for(;users;users=users->next)
1007     {
1008       err = classify_user_id (users->d, &desc, 1);
1009       if (err || (desc.mode    != KEYDB_SEARCH_MODE_SHORT_KID
1010                   && desc.mode != KEYDB_SEARCH_MODE_LONG_KID
1011                   && desc.mode != KEYDB_SEARCH_MODE_FPR16
1012                   && desc.mode != KEYDB_SEARCH_MODE_FPR20))
1013         {
1014           log_error(_("\"%s\" not a key ID: skipping\n"),users->d);
1015           continue;
1016         }
1017       else
1018         append_to_strlist(&sl,users->d);
1019     }
1020
1021   if(sl)
1022     {
1023       rc = keyserver_put (ctrl, sl, opt.keyserver);
1024       free_strlist(sl);
1025     }
1026
1027   return rc;
1028 }
1029
1030 int
1031 keyserver_import (ctrl_t ctrl, strlist_t users)
1032 {
1033   gpg_error_t err;
1034   KEYDB_SEARCH_DESC *desc;
1035   int num=100,count=0;
1036   int rc=0;
1037
1038   /* Build a list of key ids */
1039   desc=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
1040
1041   for(;users;users=users->next)
1042     {
1043       err = classify_user_id (users->d, &desc[count], 1);
1044       if (err || (desc[count].mode    != KEYDB_SEARCH_MODE_SHORT_KID
1045                   && desc[count].mode != KEYDB_SEARCH_MODE_LONG_KID
1046                   && desc[count].mode != KEYDB_SEARCH_MODE_FPR16
1047                   && desc[count].mode != KEYDB_SEARCH_MODE_FPR20))
1048         {
1049           log_error (_("\"%s\" not a key ID: skipping\n"), users->d);
1050           continue;
1051         }
1052
1053       count++;
1054       if(count==num)
1055         {
1056           num+=100;
1057           desc=xrealloc(desc,sizeof(KEYDB_SEARCH_DESC)*num);
1058         }
1059     }
1060
1061   if(count>0)
1062     rc=keyserver_get (ctrl, desc, count, NULL);
1063
1064   xfree(desc);
1065
1066   return rc;
1067 }
1068
1069 int
1070 keyserver_import_fprint (ctrl_t ctrl, const byte *fprint,size_t fprint_len,
1071                          struct keyserver_spec *keyserver)
1072 {
1073   KEYDB_SEARCH_DESC desc;
1074
1075   memset(&desc,0,sizeof(desc));
1076
1077   if(fprint_len==16)
1078     desc.mode=KEYDB_SEARCH_MODE_FPR16;
1079   else if(fprint_len==20)
1080     desc.mode=KEYDB_SEARCH_MODE_FPR20;
1081   else
1082     return -1;
1083
1084   memcpy(desc.u.fpr,fprint,fprint_len);
1085
1086   /* TODO: Warn here if the fingerprint we got doesn't match the one
1087      we asked for? */
1088   return keyserver_get (ctrl, &desc, 1, keyserver);
1089 }
1090
1091 int
1092 keyserver_import_keyid (ctrl_t ctrl,
1093                         u32 *keyid,struct keyserver_spec *keyserver)
1094 {
1095   KEYDB_SEARCH_DESC desc;
1096
1097   memset(&desc,0,sizeof(desc));
1098
1099   desc.mode=KEYDB_SEARCH_MODE_LONG_KID;
1100   desc.u.kid[0]=keyid[0];
1101   desc.u.kid[1]=keyid[1];
1102
1103   return keyserver_get (ctrl, &desc,1, keyserver);
1104 }
1105
1106 /* code mostly stolen from do_export_stream */
1107 static int
1108 keyidlist(strlist_t users,KEYDB_SEARCH_DESC **klist,int *count,int fakev3)
1109 {
1110   int rc=0,ndesc,num=100;
1111   KBNODE keyblock=NULL,node;
1112   KEYDB_HANDLE kdbhd;
1113   KEYDB_SEARCH_DESC *desc;
1114   strlist_t sl;
1115
1116   *count=0;
1117
1118   *klist=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
1119
1120   kdbhd=keydb_new ();
1121
1122   if(!users)
1123     {
1124       ndesc = 1;
1125       desc = xmalloc_clear ( ndesc * sizeof *desc);
1126       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1127     }
1128   else
1129     {
1130       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
1131         ;
1132       desc = xmalloc ( ndesc * sizeof *desc);
1133
1134       for (ndesc=0, sl=users; sl; sl = sl->next)
1135         {
1136           gpg_error_t err;
1137           if (!(err = classify_user_id (sl->d, desc+ndesc, 1)))
1138             ndesc++;
1139           else
1140             log_error (_("key \"%s\" not found: %s\n"),
1141                        sl->d, gpg_strerror (err));
1142         }
1143     }
1144
1145   while (!(rc = keydb_search (kdbhd, desc, ndesc, NULL)))
1146     {
1147       if (!users)
1148         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1149
1150       /* read the keyblock */
1151       rc = keydb_get_keyblock (kdbhd, &keyblock );
1152       if( rc )
1153         {
1154           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
1155           goto leave;
1156         }
1157
1158       if((node=find_kbnode(keyblock,PKT_PUBLIC_KEY)))
1159         {
1160           /* This is to work around a bug in some keyservers (pksd and
1161              OKS) that calculate v4 RSA keyids as if they were v3 RSA.
1162              The answer is to refresh both the correct v4 keyid
1163              (e.g. 99242560) and the fake v3 keyid (e.g. 68FDDBC7).
1164              This only happens for key refresh using the HKP scheme
1165              and if the refresh-add-fake-v3-keyids keyserver option is
1166              set. */
1167           if(fakev3 && is_RSA(node->pkt->pkt.public_key->pubkey_algo) &&
1168              node->pkt->pkt.public_key->version>=4)
1169             {
1170               (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
1171               v3_keyid (node->pkt->pkt.public_key->pkey[0],
1172                         (*klist)[*count].u.kid);
1173               (*count)++;
1174
1175               if(*count==num)
1176                 {
1177                   num+=100;
1178                   *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
1179                 }
1180             }
1181
1182           /* v4 keys get full fingerprints.  v3 keys get long keyids.
1183              This is because it's easy to calculate any sort of keyid
1184              from a v4 fingerprint, but not a v3 fingerprint. */
1185
1186           if(node->pkt->pkt.public_key->version<4)
1187             {
1188               (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
1189               keyid_from_pk(node->pkt->pkt.public_key,
1190                             (*klist)[*count].u.kid);
1191             }
1192           else
1193             {
1194               size_t dummy;
1195
1196               (*klist)[*count].mode=KEYDB_SEARCH_MODE_FPR20;
1197               fingerprint_from_pk(node->pkt->pkt.public_key,
1198                                   (*klist)[*count].u.fpr,&dummy);
1199             }
1200
1201           /* This is a little hackish, using the skipfncvalue as a
1202              void* pointer to the keyserver spec, but we don't need
1203              the skipfnc here, and it saves having an additional field
1204              for this (which would be wasted space most of the
1205              time). */
1206
1207           (*klist)[*count].skipfncvalue=NULL;
1208
1209           /* Are we honoring preferred keyservers? */
1210           if(opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1211             {
1212               PKT_user_id *uid=NULL;
1213               PKT_signature *sig=NULL;
1214
1215               merge_keys_and_selfsig(keyblock);
1216
1217               for(node=node->next;node;node=node->next)
1218                 {
1219                   if(node->pkt->pkttype==PKT_USER_ID
1220                      && node->pkt->pkt.user_id->is_primary)
1221                     uid=node->pkt->pkt.user_id;
1222                   else if(node->pkt->pkttype==PKT_SIGNATURE
1223                           && node->pkt->pkt.signature->
1224                           flags.chosen_selfsig && uid)
1225                     {
1226                       sig=node->pkt->pkt.signature;
1227                       break;
1228                     }
1229                 }
1230
1231               /* Try and parse the keyserver URL.  If it doesn't work,
1232                  then we end up writing NULL which indicates we are
1233                  the same as any other key. */
1234               if(sig)
1235                 (*klist)[*count].skipfncvalue=parse_preferred_keyserver(sig);
1236             }
1237
1238           (*count)++;
1239
1240           if(*count==num)
1241             {
1242               num+=100;
1243               *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
1244             }
1245         }
1246     }
1247
1248   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1249     rc = 0;
1250
1251  leave:
1252   if(rc)
1253     xfree(*klist);
1254   xfree(desc);
1255   keydb_release(kdbhd);
1256   release_kbnode(keyblock);
1257
1258   return rc;
1259 }
1260
1261 /* Note this is different than the original HKP refresh.  It allows
1262    usernames to refresh only part of the keyring. */
1263
1264 int
1265 keyserver_refresh (ctrl_t ctrl, strlist_t users)
1266 {
1267   int rc,count,numdesc,fakev3=0;
1268   KEYDB_SEARCH_DESC *desc;
1269   unsigned int options=opt.keyserver_options.import_options;
1270
1271   /* We switch merge-only on during a refresh, as 'refresh' should
1272      never import new keys, even if their keyids match. */
1273   opt.keyserver_options.import_options|=IMPORT_MERGE_ONLY;
1274
1275   /* Similarly, we switch on fast-import, since refresh may make
1276      multiple import sets (due to preferred keyserver URLs).  We don't
1277      want each set to rebuild the trustdb.  Instead we do it once at
1278      the end here. */
1279   opt.keyserver_options.import_options|=IMPORT_FAST;
1280
1281   /* If refresh_add_fake_v3_keyids is on and it's a HKP or MAILTO
1282      scheme, then enable fake v3 keyid generation. */
1283   if((opt.keyserver_options.options&KEYSERVER_ADD_FAKE_V3) && opt.keyserver
1284      && (ascii_strcasecmp(opt.keyserver->scheme,"hkp")==0 ||
1285          ascii_strcasecmp(opt.keyserver->scheme,"mailto")==0))
1286     fakev3=1;
1287
1288   rc=keyidlist(users,&desc,&numdesc,fakev3);
1289   if(rc)
1290     return rc;
1291
1292   count=numdesc;
1293   if(count>0)
1294     {
1295       int i;
1296
1297       /* Try to handle preferred keyserver keys first */
1298       for(i=0;i<numdesc;i++)
1299         {
1300           if(desc[i].skipfncvalue)
1301             {
1302               struct keyserver_spec *keyserver=desc[i].skipfncvalue;
1303
1304               /* We use the keyserver structure we parsed out before.
1305                  Note that a preferred keyserver without a scheme://
1306                  will be interpreted as hkp:// */
1307               rc = keyserver_get (ctrl, &desc[i], 1, keyserver);
1308               if(rc)
1309                 log_info(_("WARNING: unable to refresh key %s"
1310                            " via %s: %s\n"),keystr_from_desc(&desc[i]),
1311                          keyserver->uri,g10_errstr(rc));
1312               else
1313                 {
1314                   /* We got it, so mark it as NONE so we don't try and
1315                      get it again from the regular keyserver. */
1316
1317                   desc[i].mode=KEYDB_SEARCH_MODE_NONE;
1318                   count--;
1319                 }
1320
1321               free_keyserver_spec(keyserver);
1322             }
1323         }
1324     }
1325
1326   if(count>0)
1327     {
1328       if(opt.keyserver)
1329         {
1330           if(count==1)
1331             log_info(_("refreshing 1 key from %s\n"),opt.keyserver->uri);
1332           else
1333             log_info(_("refreshing %d keys from %s\n"),
1334                      count,opt.keyserver->uri);
1335         }
1336
1337       rc=keyserver_get (ctrl, desc, numdesc, NULL);
1338     }
1339
1340   xfree(desc);
1341
1342   opt.keyserver_options.import_options=options;
1343
1344   /* If the original options didn't have fast import, and the trustdb
1345      is dirty, rebuild. */
1346   if(!(opt.keyserver_options.import_options&IMPORT_FAST))
1347     check_or_update_trustdb ();
1348
1349   return rc;
1350 }
1351
1352
1353 /* Search for keys on the keyservers.  The patterns are given in the
1354    string list TOKENS.  */
1355 gpg_error_t
1356 keyserver_search (ctrl_t ctrl, strlist_t tokens)
1357 {
1358   gpg_error_t err;
1359   char *searchstr;
1360   struct search_line_handler_parm_s parm;
1361
1362   memset (&parm, 0, sizeof parm);
1363
1364   if (!tokens)
1365     return 0;  /* Return success if no patterns are given.  */
1366
1367   if (!opt.keyserver)
1368     {
1369       log_error (_("no keyserver known (use option --keyserver)\n"));
1370       return gpg_error (GPG_ERR_NO_KEYSERVER);
1371     }
1372
1373   /* Write global options */
1374
1375   /* for(temp=opt.keyserver_options.other;temp;temp=temp->next) */
1376   /*   fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
1377
1378   /* Write per-keyserver options */
1379
1380   /* for(temp=keyserver->options;temp;temp=temp->next) */
1381   /*   fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
1382
1383   {
1384     membuf_t mb;
1385     strlist_t item;
1386
1387     init_membuf (&mb, 1024);
1388     for (item = tokens; item; item = item->next)
1389     {
1390       if (item != tokens)
1391         put_membuf (&mb, " ", 1);
1392       put_membuf_str (&mb, item->d);
1393     }
1394     put_membuf (&mb, "", 1); /* Append Nul.  */
1395     searchstr = get_membuf (&mb, NULL);
1396     if (!searchstr)
1397       {
1398         err = gpg_error_from_syserror ();
1399         goto leave;
1400       }
1401   }
1402   /* FIXME: Enable the next line */
1403   /* log_info (_("searching for \"%s\" from %s\n"), searchstr, keyserver->uri); */
1404
1405   parm.ctrl = ctrl;
1406   if (searchstr)
1407     parm.searchstr_disp = utf8_to_native (searchstr, strlen (searchstr), 0);
1408
1409   err = gpg_dirmngr_ks_search (ctrl, searchstr, search_line_handler, &parm);
1410
1411   if (parm.not_found)
1412     {
1413       if (parm.searchstr_disp)
1414         log_info (_("key \"%s\" not found on keyserver\n"),
1415                   parm.searchstr_disp);
1416       else
1417         log_info (_("key not found on keyserver\n"));
1418     }
1419
1420   if (gpg_err_code (err) == GPG_ERR_NO_KEYSERVER)
1421     log_error (_("no keyserver known (use option --keyserver)\n"));
1422   else if (err)
1423     log_error ("error searching keyserver: %s\n", gpg_strerror (err));
1424
1425   /* switch(ret) */
1426   /*   { */
1427   /*   case KEYSERVER_SCHEME_NOT_FOUND: */
1428   /*     log_error(_("no handler for keyserver scheme '%s'\n"), */
1429   /*        opt.keyserver->scheme); */
1430   /*     break; */
1431
1432   /*   case KEYSERVER_NOT_SUPPORTED: */
1433   /*     log_error(_("action '%s' not supported with keyserver " */
1434   /*          "scheme '%s'\n"), "search", opt.keyserver->scheme); */
1435   /*     break; */
1436
1437   /*   case KEYSERVER_TIMEOUT: */
1438   /*     log_error(_("keyserver timed out\n")); */
1439   /*     break; */
1440
1441   /*   case KEYSERVER_INTERNAL_ERROR: */
1442   /*   default: */
1443   /*     log_error(_("keyserver internal error\n")); */
1444   /*     break; */
1445   /*   } */
1446
1447   /* return gpg_error (GPG_ERR_KEYSERVER); */
1448
1449
1450  leave:
1451   xfree (parm.desc);
1452   xfree (parm.searchstr_disp);
1453   xfree(searchstr);
1454
1455   return err;
1456 }
1457
1458
1459
1460 /* Called using:
1461
1462 import_name:
1463   rc = keyserver_work (ctrl, KS_GETNAME, list, NULL,
1464                        0, fpr, fpr_len, keyserver);
1465
1466 import_ldap:
1467   rc = keyserver_work (ctrl, KS_GETNAME, list, NULL,
1468                        0, fpr, fpr_len, keyserver);
1469
1470  */
1471
1472 static gpg_error_t
1473 keyserver_get (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
1474                struct keyserver_spec *keyserver)
1475
1476 {
1477   gpg_error_t err = 0;
1478   char **pattern;
1479   int idx, npat;
1480   estream_t datastream;
1481
1482   /* Create an array filled with a search pattern for each key.  The
1483      array is delimited by a NULL entry.  */
1484   pattern = xtrycalloc (ndesc+1, sizeof *pattern);
1485   if (!pattern)
1486     return gpg_error_from_syserror ();
1487   for (npat=idx=0; idx < ndesc; idx++)
1488     {
1489       int quiet = 0;
1490
1491       if (desc[idx].mode == KEYDB_SEARCH_MODE_FPR20
1492           || desc[idx].mode == KEYDB_SEARCH_MODE_FPR16)
1493         {
1494           pattern[npat] = xtrymalloc (2+2*20+1);
1495           if (!pattern[npat])
1496             err = gpg_error_from_syserror ();
1497           else
1498             {
1499               strcpy (pattern[npat], "0x");
1500               bin2hex (desc[idx].u.fpr,
1501                        desc[idx].mode == KEYDB_SEARCH_MODE_FPR20? 20 : 16,
1502                        pattern[npat]+2);
1503               npat++;
1504             }
1505         }
1506       else if(desc[idx].mode == KEYDB_SEARCH_MODE_LONG_KID)
1507         {
1508           pattern[npat] = xtryasprintf ("0x%08lX%08lX",
1509                                         (ulong)desc[idx].u.kid[0],
1510                                         (ulong)desc[idx].u.kid[1]);
1511           if (!pattern[npat])
1512             err = gpg_error_from_syserror ();
1513           else
1514             npat++;
1515         }
1516       else if(desc[idx].mode == KEYDB_SEARCH_MODE_SHORT_KID)
1517         {
1518           pattern[npat] = xtryasprintf ("0x%08lX", (ulong)desc[idx].u.kid[1]);
1519           if (!pattern[npat])
1520             err = gpg_error_from_syserror ();
1521           else
1522             npat++;
1523         }
1524       else if(desc[idx].mode == KEYDB_SEARCH_MODE_EXACT)
1525         {
1526           /* FIXME: We don't need this.  It is used as a dummy by
1527              keyserver_fetch which passes an entire URL.  Better use a
1528              separate function here. */
1529           pattern[npat] = xtrystrdup ("0x0000000000000000");
1530           if (!pattern[npat])
1531             err = gpg_error_from_syserror ();
1532           else
1533             {
1534               npat++;
1535               quiet = 1;
1536             }
1537         }
1538       else if (desc[idx].mode == KEYDB_SEARCH_MODE_NONE)
1539         continue;
1540       else
1541         BUG();
1542
1543       if (err)
1544         {
1545           for (idx=0; idx < npat; idx++)
1546             xfree (pattern[idx]);
1547           xfree (pattern);
1548           return err;
1549         }
1550
1551       if (!quiet && keyserver)
1552         {
1553           if (keyserver->host)
1554             log_info (_("requesting key %s from %s server %s\n"),
1555                       keystr_from_desc (&desc[idx]),
1556                       keyserver->scheme, keyserver->host);
1557           else
1558             log_info (_("requesting key %s from %s\n"),
1559                       keystr_from_desc (&desc[idx]), keyserver->uri);
1560         }
1561     }
1562
1563
1564   err = gpg_dirmngr_ks_get (ctrl, pattern, &datastream);
1565   for (idx=0; idx < npat; idx++)
1566     xfree (pattern[idx]);
1567   xfree (pattern);
1568   if (!err)
1569     {
1570       void *stats_handle;
1571
1572       stats_handle = import_new_stats_handle();
1573
1574       /* FIXME: Check whether this comment should be moved to dirmngr.
1575
1576          Slurp up all the key data.  In the future, it might be nice
1577          to look for KEY foo OUTOFBAND and FAILED indicators.  It's
1578          harmless to ignore them, but ignoring them does make gpg
1579          complain about "no valid OpenPGP data found".  One way to do
1580          this could be to continue parsing this line-by-line and make
1581          a temp iobuf for each key.  Note that we don't allow the
1582          import of secret keys from a keyserver.  Keyservers should
1583          never accept or send them but we better protect against rogue
1584          keyservers. */
1585
1586       import_keys_es_stream (ctrl, datastream, stats_handle, NULL, NULL,
1587                              (opt.keyserver_options.import_options
1588                               | IMPORT_NO_SECKEY));
1589       import_print_stats (stats_handle);
1590       import_release_stats_handle (stats_handle);
1591     }
1592   es_fclose (datastream);
1593
1594
1595   return err;
1596 }
1597
1598
1599 /* Send all keys specified by KEYSPECS to the KEYSERVERS.  */
1600 static gpg_error_t
1601 keyserver_put (ctrl_t ctrl, strlist_t keyspecs,
1602                struct keyserver_spec *keyserver)
1603
1604 {
1605   gpg_error_t err;
1606   strlist_t kspec;
1607
1608   if (!keyspecs)
1609     return 0;  /* Return success if the list is empty.  */
1610
1611   if (!opt.keyserver)
1612     {
1613       log_error (_("no keyserver known (use option --keyserver)\n"));
1614       return gpg_error (GPG_ERR_NO_KEYSERVER);
1615     }
1616
1617   for (kspec = keyspecs; kspec; kspec = kspec->next)
1618     {
1619       void *data;
1620       size_t datalen;
1621       kbnode_t keyblock;
1622
1623       err = export_pubkey_buffer (ctrl, kspec->d,
1624                                   opt.keyserver_options.export_options,
1625                                   &keyblock, &data, &datalen);
1626       if (err)
1627         log_error (_("skipped \"%s\": %s\n"), kspec->d, gpg_strerror (err));
1628       else
1629         {
1630           if (keyserver->host)
1631             log_info (_("sending key %s to %s server %s\n"),
1632                       keystr (keyblock->pkt->pkt.public_key->keyid),
1633                       keyserver->scheme, keyserver->host);
1634           else
1635             log_info (_("sending key %s to %s\n"),
1636                       keystr (keyblock->pkt->pkt.public_key->keyid),
1637                       keyserver->uri);
1638
1639           err = gpg_dirmngr_ks_put (ctrl, data, datalen, keyblock);
1640           release_kbnode (keyblock);
1641           xfree (data);
1642           if (err)
1643             log_error (_("keyserver send failed: %s\n"), gpg_strerror (err));
1644         }
1645     }
1646
1647
1648   return err;
1649
1650 }
1651
1652
1653 int
1654 keyserver_fetch (ctrl_t ctrl, strlist_t urilist)
1655 {
1656   gpg_error_t err;
1657   strlist_t sl;
1658   estream_t datastream;
1659   unsigned int options = opt.keyserver_options.import_options;
1660
1661   /* Switch on fast-import, since fetch can handle more than one
1662      import and we don't want each set to rebuild the trustdb.
1663      Instead we do it once at the end. */
1664   opt.keyserver_options.import_options |= IMPORT_FAST;
1665
1666   for (sl=urilist; sl; sl=sl->next)
1667     {
1668       if (!opt.quiet)
1669         log_info (_("requesting key from '%s'\n"), sl->d);
1670
1671       err = gpg_dirmngr_ks_fetch (ctrl, sl->d, &datastream);
1672       if (!err)
1673         {
1674           void *stats_handle;
1675
1676           stats_handle = import_new_stats_handle();
1677           import_keys_es_stream (ctrl, datastream, stats_handle, NULL, NULL,
1678                                  opt.keyserver_options.import_options);
1679
1680           import_print_stats (stats_handle);
1681           import_release_stats_handle (stats_handle);
1682         }
1683       else
1684         log_info (_("WARNING: unable to fetch URI %s: %s\n"),
1685                   sl->d, gpg_strerror (err));
1686       es_fclose (datastream);
1687     }
1688
1689   opt.keyserver_options.import_options = options;
1690
1691   /* If the original options didn't have fast import, and the trustdb
1692      is dirty, rebuild. */
1693   if (!(opt.keyserver_options.import_options&IMPORT_FAST))
1694     check_or_update_trustdb ();
1695
1696   return 0;
1697 }
1698
1699
1700 /* Import key in a CERT or pointed to by a CERT */
1701 int
1702 keyserver_import_cert (ctrl_t ctrl,
1703                        const char *name,unsigned char **fpr,size_t *fpr_len)
1704 {
1705   gpg_error_t err;
1706   char *domain,*look,*url;
1707   estream_t key;
1708
1709
1710   look=xstrdup(name);
1711
1712   domain=strrchr(look,'@');
1713   if(domain)
1714     *domain='.';
1715
1716   err = get_dns_cert (look, &key, fpr, fpr_len, &url);
1717   if (err)
1718     ;
1719   else if (key)
1720     {
1721       int armor_status=opt.no_armor;
1722
1723       /* CERTs are always in binary format */
1724       opt.no_armor=1;
1725
1726       err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
1727                                    (opt.keyserver_options.import_options
1728                                     | IMPORT_NO_SECKEY));
1729
1730       opt.no_armor=armor_status;
1731
1732       es_fclose (key);
1733       key = NULL;
1734     }
1735   else if (*fpr)
1736     {
1737       /* We only consider the IPGP type if a fingerprint was provided.
1738          This lets us select the right key regardless of what a URL
1739          points to, or get the key from a keyserver. */
1740       if(url)
1741         {
1742           struct keyserver_spec *spec;
1743
1744           spec=parse_keyserver_uri(url,1,NULL,0);
1745           if(spec)
1746             {
1747               err = keyserver_import_fprint (ctrl, *fpr,*fpr_len,spec);
1748               free_keyserver_spec(spec);
1749             }
1750         }
1751       else if(opt.keyserver)
1752         {
1753           /* If only a fingerprint is provided, try and fetch it from
1754              our --keyserver */
1755
1756           err = keyserver_import_fprint (ctrl, *fpr,*fpr_len,opt.keyserver);
1757         }
1758       else
1759         log_info(_("no keyserver known (use option --keyserver)\n"));
1760
1761       /* Give a better string here? "CERT fingerprint for \"%s\"
1762          found, but no keyserver" " known (use option
1763          --keyserver)\n" ? */
1764
1765     }
1766
1767   xfree(url);
1768   xfree(look);
1769
1770   return err;
1771 }
1772
1773 /* Import key pointed to by a PKA record. Return the requested
1774    fingerprint in fpr. */
1775 int
1776 keyserver_import_pka (ctrl_t ctrl,
1777                       const char *name,unsigned char **fpr,size_t *fpr_len)
1778 {
1779   char *uri;
1780   int rc = G10ERR_NO_PUBKEY;
1781
1782   *fpr = xmalloc (20);
1783   *fpr_len = 20;
1784
1785   uri = get_pka_info (name, *fpr);
1786   if (uri && *uri)
1787     {
1788       /* An URI is available.  Lookup the key. */
1789       struct keyserver_spec *spec;
1790       spec = parse_keyserver_uri (uri, 1, NULL, 0);
1791       if (spec)
1792         {
1793           rc = keyserver_import_fprint (ctrl, *fpr, 20, spec);
1794           free_keyserver_spec (spec);
1795         }
1796       xfree (uri);
1797     }
1798
1799   if (rc)
1800     {
1801       xfree(*fpr);
1802       *fpr = NULL;
1803     }
1804
1805   return rc;
1806 }
1807
1808 /* Import all keys that match name */
1809 int
1810 keyserver_import_name (ctrl_t ctrl, const char *name,
1811                        unsigned char **fpr, size_t *fpr_len,
1812                        struct keyserver_spec *keyserver)
1813 {
1814   strlist_t list=NULL;
1815   int rc;
1816
1817   append_to_strlist(&list,name);
1818
1819   rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED);  /* FIXME */
1820        /* keyserver_work (ctrl, KS_GETNAME, list, NULL, */
1821        /*                 0, fpr, fpr_len, keyserver); */
1822
1823   free_strlist(list);
1824
1825   return rc;
1826 }
1827
1828 /* Import a key by name using LDAP */
1829 int
1830 keyserver_import_ldap (ctrl_t ctrl,
1831                        const char *name,unsigned char **fpr,size_t *fpr_len)
1832 {
1833   char *domain;
1834   struct keyserver_spec *keyserver;
1835   strlist_t list=NULL;
1836   int rc,hostlen=1;
1837 #ifdef USE_DNS_SRV
1838   struct srventry *srvlist=NULL;
1839   int srvcount,i;
1840   char srvname[MAXDNAME];
1841 #endif
1842
1843   /* Parse out the domain */
1844   domain=strrchr(name,'@');
1845   if(!domain)
1846     return G10ERR_GENERAL;
1847
1848   domain++;
1849
1850   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
1851   keyserver->scheme=xstrdup("ldap");
1852   keyserver->host=xmalloc(1);
1853   keyserver->host[0]='\0';
1854
1855 #ifdef USE_DNS_SRV
1856   snprintf(srvname,MAXDNAME,"_pgpkey-ldap._tcp.%s",domain);
1857
1858   srvcount=getsrv(srvname,&srvlist);
1859
1860   for(i=0;i<srvcount;i++)
1861     {
1862       hostlen+=strlen(srvlist[i].target)+1;
1863       keyserver->host=xrealloc(keyserver->host,hostlen);
1864
1865       strcat(keyserver->host,srvlist[i].target);
1866
1867       if(srvlist[i].port!=389)
1868         {
1869           char port[7];
1870
1871           hostlen+=6; /* a colon, plus 5 digits (unsigned 16-bit value) */
1872           keyserver->host=xrealloc(keyserver->host,hostlen);
1873
1874           snprintf(port,7,":%u",srvlist[i].port);
1875           strcat(keyserver->host,port);
1876         }
1877
1878       strcat(keyserver->host," ");
1879     }
1880
1881   free(srvlist);
1882 #endif
1883
1884   /* If all else fails, do the PGP Universal trick of
1885      ldap://keys.(domain) */
1886
1887   hostlen+=5+strlen(domain);
1888   keyserver->host=xrealloc(keyserver->host,hostlen);
1889   strcat(keyserver->host,"keys.");
1890   strcat(keyserver->host,domain);
1891
1892   append_to_strlist(&list,name);
1893
1894   rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
1895        /* keyserver_work (ctrl, KS_GETNAME, list, NULL, */
1896        /*                 0, fpr, fpr_len, keyserver); */
1897
1898   free_strlist(list);
1899
1900   free_keyserver_spec(keyserver);
1901
1902   return rc;
1903 }