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