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