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