gpg: Accept also armored data from the WKD.
[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 <https://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 <errno.h>
28
29 #include "gpg.h"
30 #include "../common/iobuf.h"
31 #include "filter.h"
32 #include "keydb.h"
33 #include "../common/status.h"
34 #include "exec.h"
35 #include "main.h"
36 #include "../common/i18n.h"
37 #include "../common/ttyio.h"
38 #include "options.h"
39 #include "packet.h"
40 #include "trustdb.h"
41 #include "keyserver-internal.h"
42 #include "../common/util.h"
43 #include "../common/membuf.h"
44 #include "../common/mbox-util.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                                   int quick,
112                                   unsigned char **r_fpr, size_t *r_fprlen);
113 static gpg_error_t keyserver_put (ctrl_t ctrl, strlist_t keyspecs);
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, *duped_uri, *options;
246
247   log_assert (string);
248
249   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
250
251   duped_uri = 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   xfree (duped_uri);
440   return keyserver;
441
442  fail:
443   free_keyserver_spec(keyserver);
444
445   xfree (duped_uri);
446   return NULL;
447 }
448
449 struct keyserver_spec *
450 parse_preferred_keyserver(PKT_signature *sig)
451 {
452   struct keyserver_spec *spec=NULL;
453   const byte *p;
454   size_t plen;
455
456   p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&plen);
457   if(p && plen)
458     {
459       byte *dupe=xmalloc(plen+1);
460
461       memcpy(dupe,p,plen);
462       dupe[plen]='\0';
463       spec = parse_keyserver_uri (dupe, 1);
464       xfree(dupe);
465     }
466
467   return spec;
468 }
469
470 static void
471 print_keyrec (ctrl_t ctrl, int number,struct keyrec *keyrec)
472 {
473
474   iobuf_writebyte(keyrec->uidbuf,0);
475   iobuf_flush_temp(keyrec->uidbuf);
476   es_printf ("(%d)\t%s  ", number, iobuf_get_temp_buffer (keyrec->uidbuf));
477
478   if (keyrec->size>0)
479     es_printf ("%d bit ", keyrec->size);
480
481   if(keyrec->type)
482     {
483       const char *str;
484
485       str = openpgp_pk_algo_name (keyrec->type);
486
487       if (str && strcmp (str, "?"))
488         es_printf ("%s ",str);
489       else
490         es_printf ("unknown ");
491     }
492
493   switch(keyrec->desc.mode)
494     {
495       /* If the keyserver helper gave us a short keyid, we have no
496          choice but to use it.  Do check --keyid-format to add a 0x if
497          needed. */
498     case KEYDB_SEARCH_MODE_SHORT_KID:
499       es_printf ("key %s%08lX",
500                  (opt.keyid_format==KF_0xSHORT
501                   || opt.keyid_format==KF_0xLONG)?"0x":"",
502                  (ulong)keyrec->desc.u.kid[1]);
503       break;
504
505       /* However, if it gave us a long keyid, we can honor
506          --keyid-format via keystr(). */
507     case KEYDB_SEARCH_MODE_LONG_KID:
508       es_printf ("key %s",keystr(keyrec->desc.u.kid));
509       break;
510
511     case KEYDB_SEARCH_MODE_FPR:
512       {
513         u32 kid[2];
514         keyid_from_fingerprint (ctrl, keyrec->desc.u.fpr, keyrec->desc.fprlen,
515                                 kid);
516         es_printf("key %s",keystr(kid));
517       }
518       break;
519
520     default:
521       BUG();
522       break;
523     }
524
525   if(keyrec->createtime>0)
526     {
527       es_printf (", ");
528       es_printf (_("created: %s"), strtimestamp(keyrec->createtime));
529     }
530
531   if(keyrec->expiretime>0)
532     {
533       es_printf (", ");
534       es_printf (_("expires: %s"), strtimestamp(keyrec->expiretime));
535     }
536
537   if (keyrec->flags&1)
538     es_printf (" (%s)", _("revoked"));
539   if(keyrec->flags&2)
540     es_printf (" (%s)", _("disabled"));
541   if(keyrec->flags&4)
542     es_printf (" (%s)", _("expired"));
543
544   es_printf ("\n");
545 }
546
547 /* Returns a keyrec (which must be freed) once a key is complete, and
548    NULL otherwise.  Call with a NULL keystring once key parsing is
549    complete to return any unfinished keys. */
550 static struct keyrec *
551 parse_keyrec(char *keystring)
552 {
553   /* FIXME: Remove the static and put the data into the parms we use
554      for the caller anyway.  */
555   static struct keyrec *work=NULL;
556   struct keyrec *ret=NULL;
557   char *record;
558   int i;
559
560   if(keystring==NULL)
561     {
562       if(work==NULL)
563         return NULL;
564       else if(work->desc.mode==KEYDB_SEARCH_MODE_NONE)
565         {
566           xfree(work);
567           return NULL;
568         }
569       else
570         {
571           ret=work;
572           work=NULL;
573           return ret;
574         }
575     }
576
577   if(work==NULL)
578     {
579       work=xmalloc_clear(sizeof(struct keyrec));
580       work->uidbuf=iobuf_temp();
581     }
582
583   trim_trailing_ws (keystring, strlen (keystring));
584
585   if((record=strsep(&keystring,":"))==NULL)
586     return ret;
587
588   if(ascii_strcasecmp("pub",record)==0)
589     {
590       char *tok;
591       gpg_error_t err;
592
593       if(work->desc.mode)
594         {
595           ret=work;
596           work=xmalloc_clear(sizeof(struct keyrec));
597           work->uidbuf=iobuf_temp();
598         }
599
600       if((tok=strsep(&keystring,":"))==NULL)
601         return ret;
602
603       err = classify_user_id (tok, &work->desc, 1);
604       if (err || (work->desc.mode    != KEYDB_SEARCH_MODE_SHORT_KID
605                   && work->desc.mode != KEYDB_SEARCH_MODE_LONG_KID
606                   && work->desc.mode != KEYDB_SEARCH_MODE_FPR))
607         {
608           work->desc.mode=KEYDB_SEARCH_MODE_NONE;
609           return ret;
610         }
611
612       /* Note all items after this are optional.  This allows us to
613          have a pub line as simple as pub:keyid and nothing else. */
614
615       work->lines++;
616
617       if((tok=strsep(&keystring,":"))==NULL)
618         return ret;
619
620       work->type=atoi(tok);
621
622       if((tok=strsep(&keystring,":"))==NULL)
623         return ret;
624
625       work->size=atoi(tok);
626
627       if((tok=strsep(&keystring,":"))==NULL)
628         return ret;
629
630       if(atoi(tok)<=0)
631         work->createtime=0;
632       else
633         work->createtime=atoi(tok);
634
635       if((tok=strsep(&keystring,":"))==NULL)
636         return ret;
637
638       if(atoi(tok)<=0)
639         work->expiretime=0;
640       else
641         {
642           work->expiretime=atoi(tok);
643           /* Force the 'e' flag on if this key is expired. */
644           if(work->expiretime<=make_timestamp())
645             work->flags|=4;
646         }
647
648       if((tok=strsep(&keystring,":"))==NULL)
649         return ret;
650
651       while(*tok)
652         switch(*tok++)
653           {
654           case 'r':
655           case 'R':
656             work->flags|=1;
657             break;
658
659           case 'd':
660           case 'D':
661             work->flags|=2;
662             break;
663
664           case 'e':
665           case 'E':
666             work->flags|=4;
667             break;
668           }
669     }
670   else if(ascii_strcasecmp("uid",record)==0 && work->desc.mode)
671     {
672       char *userid,*tok,*decoded;
673
674       if((tok=strsep(&keystring,":"))==NULL)
675         return ret;
676
677       if(strlen(tok)==0)
678         return ret;
679
680       userid=tok;
681
682       /* By definition, de-%-encoding is always smaller than the
683          original string so we can decode in place. */
684
685       i=0;
686
687       while(*tok)
688         if(tok[0]=='%' && tok[1] && tok[2])
689           {
690             int c;
691
692             userid[i] = (c=hextobyte(&tok[1])) == -1 ? '?' : c;
693             i++;
694             tok+=3;
695           }
696         else
697           userid[i++]=*tok++;
698
699       /* We don't care about the other info provided in the uid: line
700          since no keyserver supports marking userids with timestamps
701          or revoked/expired/disabled yet. */
702
703       /* No need to check for control characters, as utf8_to_native
704          does this for us. */
705
706       decoded=utf8_to_native(userid,i,0);
707       if(strlen(decoded)>opt.screen_columns-10)
708         decoded[opt.screen_columns-10]='\0';
709       iobuf_writestr(work->uidbuf,decoded);
710       xfree(decoded);
711       iobuf_writestr(work->uidbuf,"\n\t");
712       work->lines++;
713     }
714
715   /* Ignore any records other than "pri" and "uid" for easy future
716      growth. */
717
718   return ret;
719 }
720
721 /* Show a prompt and allow the user to select keys for retrieval.  */
722 static gpg_error_t
723 show_prompt (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int numdesc,
724              int count, const char *search)
725 {
726   gpg_error_t err;
727   char *answer = NULL;
728
729   es_fflush (es_stdout);
730
731   if (count && opt.command_fd == -1)
732     {
733       static int from = 1;
734       tty_printf ("Keys %d-%d of %d for \"%s\".  ",
735                   from, numdesc, count, search);
736       from = numdesc + 1;
737     }
738
739  again:
740   err = 0;
741   xfree (answer);
742   answer = cpr_get_no_help ("keysearch.prompt",
743                             _("Enter number(s), N)ext, or Q)uit > "));
744   /* control-d */
745   if (answer[0]=='\x04')
746     {
747       tty_printf ("Q\n");
748       answer[0] = 'q';
749     }
750
751   if (answer[0]=='q' || answer[0]=='Q')
752     err = gpg_error (GPG_ERR_CANCELED);
753   else if (atoi (answer) >= 1 && atoi (answer) <= numdesc)
754     {
755       char *split = answer;
756       char *num;
757       int numarray[50];
758       int numidx = 0;
759       int idx;
760
761       while ((num = strsep (&split, " ,")))
762         if (atoi (num) >= 1 && atoi (num) <= numdesc)
763           {
764             if (numidx >= DIM (numarray))
765               {
766                 tty_printf ("Too many keys selected\n");
767                 goto again;
768               }
769             numarray[numidx++] = atoi (num);
770           }
771
772       if (!numidx)
773         goto again;
774
775       {
776         KEYDB_SEARCH_DESC *selarray;
777
778         selarray = xtrymalloc (numidx * sizeof *selarray);
779         if (!selarray)
780           {
781             err = gpg_error_from_syserror ();
782             goto leave;
783           }
784         for (idx = 0; idx < numidx; idx++)
785           selarray[idx] = desc[numarray[idx]-1];
786         err = keyserver_get (ctrl, selarray, numidx, NULL, 0, NULL, NULL);
787         xfree (selarray);
788       }
789     }
790
791  leave:
792   xfree (answer);
793   return err;
794 }
795
796
797 /* This is a callback used by call-dirmngr.c to process the result of
798    KS_SEARCH command.  If SPECIAL is 0, LINE is the actual data line
799    received with all escaping removed and guaranteed to be exactly one
800    line with stripped LF; an EOF is indicated by LINE passed as NULL.
801    If special is 1, the line contains the source of the information
802    (usually an URL).  LINE may be modified after return.  */
803 static gpg_error_t
804 search_line_handler (void *opaque, int special, char *line)
805 {
806   struct search_line_handler_parm_s *parm = opaque;
807   gpg_error_t err = 0;
808   struct keyrec *keyrec;
809
810   if (special == 1)
811     {
812       log_info ("data source: %s\n", line);
813       return 0;
814     }
815   else if (special)
816     {
817       log_debug ("unknown value %d for special search callback", special);
818       return 0;
819     }
820
821   if (parm->eof_seen && line)
822     {
823       log_debug ("ooops: unexpected data after EOF\n");
824       line = NULL;
825     }
826
827   /* Print the received line.  */
828   if (opt.with_colons && line)
829     {
830       es_printf ("%s\n", line);
831     }
832
833   /* Look for an info: line.  The only current info: values defined
834      are the version and key count. */
835   if (line && !parm->any_lines && !ascii_strncasecmp ("info:", line, 5))
836     {
837       char *str = line + 5;
838       char *tok;
839
840       if ((tok = strsep (&str, ":")))
841         {
842           int version;
843
844           if (sscanf (tok, "%d", &version) !=1 )
845             version = 1;
846
847           if (version !=1 )
848             {
849               log_error (_("invalid keyserver protocol "
850                            "(us %d!=handler %d)\n"), 1, version);
851               return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
852             }
853         }
854
855       if ((tok = strsep (&str, ":"))
856           && sscanf (tok, "%d", &parm->count) == 1)
857         {
858           if (!parm->count)
859             parm->not_found = 1;/* Server indicated that no items follow.  */
860           else if (parm->count < 0)
861             parm->count = 10;   /* Bad value - assume something reasonable.  */
862           else
863             parm->validcount = 1; /* COUNT seems to be okay.  */
864         }
865
866       parm->any_lines = 1;
867       return 0; /* Line processing finished.  */
868     }
869
870  again:
871   if (line)
872     keyrec = parse_keyrec (line);
873   else
874     {
875       /* Received EOF - flush data */
876       parm->eof_seen = 1;
877       keyrec = parse_keyrec (NULL);
878       if (!keyrec)
879         {
880           if (!parm->nkeys)
881             parm->not_found = 1;  /* No keys at all.  */
882           else
883             {
884               if (parm->nkeys != parm->count)
885                 parm->validcount = 0;
886
887               if (!(opt.with_colons && opt.batch))
888                 {
889                   err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
890                                      parm->validcount? parm->count : 0,
891                                      parm->searchstr_disp);
892                   return err;
893                 }
894             }
895         }
896     }
897
898   /* Save the key in the key array.  */
899   if (keyrec)
900     {
901       /* Allocate or enlarge the key array if needed.  */
902       if (!parm->desc)
903         {
904           if (parm->count < 1)
905             {
906               parm->count = 10;
907               parm->validcount = 0;
908             }
909           parm->desc = xtrymalloc (parm->count * sizeof *parm->desc);
910           if (!parm->desc)
911             {
912               err = gpg_error_from_syserror ();
913               iobuf_close (keyrec->uidbuf);
914               xfree (keyrec);
915               return err;
916             }
917         }
918       else if (parm->nkeys == parm->count)
919         {
920           /* Keyserver sent more keys than claimed in the info: line. */
921           KEYDB_SEARCH_DESC *tmp;
922           int newcount = parm->count + 10;
923
924           tmp = xtryrealloc (parm->desc, newcount * sizeof *parm->desc);
925           if (!tmp)
926             {
927               err = gpg_error_from_syserror ();
928               iobuf_close (keyrec->uidbuf);
929               xfree (keyrec);
930               return err;
931             }
932           parm->count = newcount;
933           parm->desc = tmp;
934           parm->validcount = 0;
935         }
936
937       parm->desc[parm->nkeys] = keyrec->desc;
938
939       if (!opt.with_colons)
940         {
941           /* SCREEN_LINES - 1 for the prompt. */
942           if (parm->numlines + keyrec->lines > opt.screen_lines - 1)
943             {
944               err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
945                                  parm->validcount ? parm->count:0,
946                                  parm->searchstr_disp);
947               if (err)
948                 return err;
949               parm->numlines = 0;
950             }
951
952           print_keyrec (parm->ctrl, parm->nkeys+1, keyrec);
953         }
954
955       parm->numlines += keyrec->lines;
956       iobuf_close (keyrec->uidbuf);
957       xfree (keyrec);
958
959       parm->any_lines = 1;
960       parm->nkeys++;
961
962       /* If we are here due to a flush after the EOF, run again for
963          the last prompt.  Fixme: Make this code better readable. */
964       if (parm->eof_seen)
965         goto again;
966     }
967
968   return 0;
969 }
970
971
972
973 int
974 keyserver_export (ctrl_t ctrl, strlist_t users)
975 {
976   gpg_error_t err;
977   strlist_t sl=NULL;
978   KEYDB_SEARCH_DESC desc;
979   int rc=0;
980
981   /* Weed out descriptors that we don't support sending */
982   for(;users;users=users->next)
983     {
984       err = classify_user_id (users->d, &desc, 1);
985       if (err || (desc.mode    != KEYDB_SEARCH_MODE_SHORT_KID
986                   && desc.mode != KEYDB_SEARCH_MODE_LONG_KID
987                   && desc.mode != KEYDB_SEARCH_MODE_FPR))
988         {
989           log_error(_("\"%s\" not a key ID: skipping\n"),users->d);
990           continue;
991         }
992       else
993         append_to_strlist(&sl,users->d);
994     }
995
996   if(sl)
997     {
998       rc = keyserver_put (ctrl, sl);
999       free_strlist(sl);
1000     }
1001
1002   return rc;
1003 }
1004
1005
1006 /* Structure to convey the arg to keyserver_retrieval_screener.  */
1007 struct ks_retrieval_screener_arg_s
1008 {
1009   KEYDB_SEARCH_DESC *desc;
1010   int ndesc;
1011 };
1012
1013
1014 /* Check whether a key matches the search description.  The function
1015    returns 0 if the key shall be imported.  */
1016 static gpg_error_t
1017 keyserver_retrieval_screener (kbnode_t keyblock, void *opaque)
1018 {
1019   struct ks_retrieval_screener_arg_s *arg = opaque;
1020   KEYDB_SEARCH_DESC *desc = arg->desc;
1021   int ndesc = arg->ndesc;
1022   kbnode_t node;
1023   PKT_public_key *pk;
1024   int n;
1025   u32 keyid[2];
1026   byte fpr[MAX_FINGERPRINT_LEN];
1027   size_t fpr_len = 0;
1028
1029   /* Secret keys are not expected from a keyserver.  We do not
1030      care about secret subkeys because the import code takes care
1031      of skipping them.  Not allowing an import of a public key
1032      with a secret subkey would make it too easy to inhibit the
1033      downloading of a public key.  Recall that keyservers do only
1034      limited checks.  */
1035   node = find_kbnode (keyblock, PKT_SECRET_KEY);
1036   if (node)
1037     return gpg_error (GPG_ERR_GENERAL);   /* Do not import. */
1038
1039   if (!ndesc)
1040     return 0; /* Okay if no description given.  */
1041
1042   /* Loop over all key packets.  */
1043   for (node = keyblock; node; node = node->next)
1044     {
1045       if (node->pkt->pkttype != PKT_PUBLIC_KEY
1046           && node->pkt->pkttype != PKT_PUBLIC_SUBKEY)
1047         continue;
1048
1049       pk = node->pkt->pkt.public_key;
1050       fingerprint_from_pk (pk, fpr, &fpr_len);
1051       keyid_from_pk (pk, keyid);
1052
1053       /* Compare requested and returned fingerprints if available. */
1054       for (n = 0; n < ndesc; n++)
1055         {
1056           if (desc[n].mode == KEYDB_SEARCH_MODE_FPR)
1057             {
1058               if (fpr_len == desc[n].fprlen && !memcmp (fpr, desc[n].u.fpr, 32))
1059                 return 0;
1060             }
1061           else if (desc[n].mode == KEYDB_SEARCH_MODE_LONG_KID)
1062             {
1063               if (keyid[0] == desc[n].u.kid[0] && keyid[1] == desc[n].u.kid[1])
1064                 return 0;
1065             }
1066           else if (desc[n].mode == KEYDB_SEARCH_MODE_SHORT_KID)
1067             {
1068               if (keyid[1] == desc[n].u.kid[1])
1069                 return 0;
1070             }
1071           else /* No keyid or fingerprint - can't check.  */
1072             return 0; /* allow import.  */
1073         }
1074     }
1075
1076   return gpg_error (GPG_ERR_GENERAL);
1077 }
1078
1079
1080 int
1081 keyserver_import (ctrl_t ctrl, strlist_t users)
1082 {
1083   gpg_error_t err;
1084   KEYDB_SEARCH_DESC *desc;
1085   int num=100,count=0;
1086   int rc=0;
1087
1088   /* Build a list of key ids */
1089   desc=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
1090
1091   for(;users;users=users->next)
1092     {
1093       err = classify_user_id (users->d, &desc[count], 1);
1094       if (err || (desc[count].mode    != KEYDB_SEARCH_MODE_SHORT_KID
1095                   && desc[count].mode != KEYDB_SEARCH_MODE_LONG_KID
1096                   && desc[count].mode != KEYDB_SEARCH_MODE_FPR))
1097         {
1098           log_error (_("\"%s\" not a key ID: skipping\n"), users->d);
1099           continue;
1100         }
1101
1102       count++;
1103       if(count==num)
1104         {
1105           num+=100;
1106           desc=xrealloc(desc,sizeof(KEYDB_SEARCH_DESC)*num);
1107         }
1108     }
1109
1110   if(count>0)
1111     rc = keyserver_get (ctrl, desc, count, NULL, 0, NULL, NULL);
1112
1113   xfree(desc);
1114
1115   return rc;
1116 }
1117
1118
1119 /* Return true if any keyserver has been configured. */
1120 int
1121 keyserver_any_configured (ctrl_t ctrl)
1122 {
1123   return !gpg_dirmngr_ks_list (ctrl, NULL);
1124 }
1125
1126
1127 /* Import all keys that exactly match NAME */
1128 int
1129 keyserver_import_name (ctrl_t ctrl, const char *name,
1130                        unsigned char **fpr, size_t *fprlen,
1131                        struct keyserver_spec *keyserver)
1132 {
1133   KEYDB_SEARCH_DESC desc;
1134
1135   memset (&desc, 0, sizeof desc);
1136
1137   desc.mode = KEYDB_SEARCH_MODE_EXACT;
1138   desc.u.name = name;
1139
1140   return keyserver_get (ctrl, &desc, 1, keyserver, 0, fpr, fprlen);
1141 }
1142
1143
1144 int
1145 keyserver_import_fprint (ctrl_t ctrl, const byte *fprint,size_t fprint_len,
1146                          struct keyserver_spec *keyserver, int quick)
1147 {
1148   KEYDB_SEARCH_DESC desc;
1149
1150   memset(&desc,0,sizeof(desc));
1151
1152   if (fprint_len == 16 || fprint_len == 20 || fprint_len == 32)
1153     desc.mode = KEYDB_SEARCH_MODE_FPR;
1154   else
1155     return -1;
1156
1157   memcpy(desc.u.fpr,fprint,fprint_len);
1158   desc.fprlen = fprint_len;
1159
1160   /* TODO: Warn here if the fingerprint we got doesn't match the one
1161      we asked for? */
1162   return keyserver_get (ctrl, &desc, 1, keyserver, quick, NULL, NULL);
1163 }
1164
1165 int
1166 keyserver_import_keyid (ctrl_t ctrl,
1167                         u32 *keyid,struct keyserver_spec *keyserver, int quick)
1168 {
1169   KEYDB_SEARCH_DESC desc;
1170
1171   memset(&desc,0,sizeof(desc));
1172
1173   desc.mode=KEYDB_SEARCH_MODE_LONG_KID;
1174   desc.u.kid[0]=keyid[0];
1175   desc.u.kid[1]=keyid[1];
1176
1177   return keyserver_get (ctrl, &desc, 1, keyserver, quick, NULL, NULL);
1178 }
1179
1180
1181 /* code mostly stolen from do_export_stream */
1182 static int
1183 keyidlist (ctrl_t ctrl, strlist_t users, KEYDB_SEARCH_DESC **klist,
1184            int *count, int fakev3)
1185 {
1186   int rc = 0;
1187   int num = 100;
1188   kbnode_t keyblock = NULL;
1189   kbnode_t node;
1190   KEYDB_HANDLE kdbhd;
1191   int ndesc;
1192   KEYDB_SEARCH_DESC *desc = NULL;
1193   strlist_t sl;
1194
1195   *count=0;
1196
1197   *klist=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
1198
1199   kdbhd = keydb_new ();
1200   if (!kdbhd)
1201     {
1202       rc = gpg_error_from_syserror ();
1203       goto leave;
1204     }
1205   keydb_disable_caching (kdbhd);  /* We are looping the search.  */
1206
1207   if(!users)
1208     {
1209       ndesc = 1;
1210       desc = xmalloc_clear ( ndesc * sizeof *desc);
1211       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1212     }
1213   else
1214     {
1215       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
1216         ;
1217       desc = xmalloc ( ndesc * sizeof *desc);
1218
1219       for (ndesc=0, sl=users; sl; sl = sl->next)
1220         {
1221           gpg_error_t err;
1222           if (!(err = classify_user_id (sl->d, desc+ndesc, 1)))
1223             ndesc++;
1224           else
1225             log_error (_("key \"%s\" not found: %s\n"),
1226                        sl->d, gpg_strerror (err));
1227         }
1228     }
1229
1230   for (;;)
1231     {
1232       rc = keydb_search (kdbhd, desc, ndesc, NULL);
1233       if (rc)
1234         break;  /* ready.  */
1235
1236       if (!users)
1237         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1238
1239       /* read the keyblock */
1240       rc = keydb_get_keyblock (kdbhd, &keyblock );
1241       if( rc )
1242         {
1243           log_error (_("error reading keyblock: %s\n"), gpg_strerror (rc) );
1244           goto leave;
1245         }
1246
1247       if((node=find_kbnode(keyblock,PKT_PUBLIC_KEY)))
1248         {
1249           /* This is to work around a bug in some keyservers (pksd and
1250              OKS) that calculate v4 RSA keyids as if they were v3 RSA.
1251              The answer is to refresh both the correct v4 keyid
1252              (e.g. 99242560) and the fake v3 keyid (e.g. 68FDDBC7).
1253              This only happens for key refresh using the HKP scheme
1254              and if the refresh-add-fake-v3-keyids keyserver option is
1255              set. */
1256           if(fakev3 && is_RSA(node->pkt->pkt.public_key->pubkey_algo) &&
1257              node->pkt->pkt.public_key->version>=4)
1258             {
1259               (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
1260               v3_keyid (node->pkt->pkt.public_key->pkey[0],
1261                         (*klist)[*count].u.kid);
1262               (*count)++;
1263
1264               if(*count==num)
1265                 {
1266                   num+=100;
1267                   *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
1268                 }
1269             }
1270
1271           /* v4 keys get full fingerprints.  v3 keys get long keyids.
1272              This is because it's easy to calculate any sort of keyid
1273              from a v4 fingerprint, but not a v3 fingerprint. */
1274
1275           if (node->pkt->pkt.public_key->version < 4)
1276             {
1277               (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
1278               keyid_from_pk(node->pkt->pkt.public_key,
1279                             (*klist)[*count].u.kid);
1280             }
1281           else
1282             {
1283               size_t fprlen;
1284
1285               fingerprint_from_pk (node->pkt->pkt.public_key,
1286                                    (*klist)[*count].u.fpr, &fprlen);
1287               (*klist)[*count].mode = KEYDB_SEARCH_MODE_FPR;
1288               (*klist)[*count].fprlen = fprlen;
1289             }
1290
1291           /* This is a little hackish, using the skipfncvalue as a
1292              void* pointer to the keyserver spec, but we don't need
1293              the skipfnc here, and it saves having an additional field
1294              for this (which would be wasted space most of the
1295              time). */
1296
1297           (*klist)[*count].skipfncvalue=NULL;
1298
1299           /* Are we honoring preferred keyservers? */
1300           if(opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1301             {
1302               PKT_user_id *uid=NULL;
1303               PKT_signature *sig=NULL;
1304
1305               merge_keys_and_selfsig (ctrl, keyblock);
1306
1307               for(node=node->next;node;node=node->next)
1308                 {
1309                   if(node->pkt->pkttype==PKT_USER_ID
1310                      && node->pkt->pkt.user_id->flags.primary)
1311                     uid=node->pkt->pkt.user_id;
1312                   else if(node->pkt->pkttype==PKT_SIGNATURE
1313                           && node->pkt->pkt.signature->
1314                           flags.chosen_selfsig && uid)
1315                     {
1316                       sig=node->pkt->pkt.signature;
1317                       break;
1318                     }
1319                 }
1320
1321               /* Try and parse the keyserver URL.  If it doesn't work,
1322                  then we end up writing NULL which indicates we are
1323                  the same as any other key. */
1324               if(sig)
1325                 (*klist)[*count].skipfncvalue=parse_preferred_keyserver(sig);
1326             }
1327
1328           (*count)++;
1329
1330           if(*count==num)
1331             {
1332               num+=100;
1333               *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
1334             }
1335         }
1336     }
1337
1338   if (gpg_err_code (rc) == GPG_ERR_NOT_FOUND)
1339     rc = 0;
1340
1341  leave:
1342   if(rc)
1343     {
1344       xfree(*klist);
1345       *klist = NULL;
1346     }
1347   xfree(desc);
1348   keydb_release(kdbhd);
1349   release_kbnode(keyblock);
1350
1351   return rc;
1352 }
1353
1354 /* Note this is different than the original HKP refresh.  It allows
1355    usernames to refresh only part of the keyring. */
1356
1357 gpg_error_t
1358 keyserver_refresh (ctrl_t ctrl, strlist_t users)
1359 {
1360   gpg_error_t err;
1361   int count, numdesc;
1362   int fakev3 = 0;
1363   KEYDB_SEARCH_DESC *desc;
1364   unsigned int options=opt.keyserver_options.import_options;
1365
1366   /* We switch merge-only on during a refresh, as 'refresh' should
1367      never import new keys, even if their keyids match. */
1368   opt.keyserver_options.import_options|=IMPORT_MERGE_ONLY;
1369
1370   /* Similarly, we switch on fast-import, since refresh may make
1371      multiple import sets (due to preferred keyserver URLs).  We don't
1372      want each set to rebuild the trustdb.  Instead we do it once at
1373      the end here. */
1374   opt.keyserver_options.import_options|=IMPORT_FAST;
1375
1376   /* If refresh_add_fake_v3_keyids is on and it's a HKP or MAILTO
1377      scheme, then enable fake v3 keyid generation.  Note that this
1378      works only with a keyserver configured. gpg.conf
1379      (i.e. opt.keyserver); however that method of configuring a
1380      keyserver is deprecated and in any case it is questionable
1381      whether we should keep on supporting these ancient and broken
1382      keyservers.  */
1383   if((opt.keyserver_options.options&KEYSERVER_ADD_FAKE_V3) && opt.keyserver
1384      && (ascii_strcasecmp(opt.keyserver->scheme,"hkp")==0 ||
1385          ascii_strcasecmp(opt.keyserver->scheme,"mailto")==0))
1386     fakev3=1;
1387
1388   err = keyidlist (ctrl, users, &desc, &numdesc, fakev3);
1389   if (err)
1390     return err;
1391
1392   count=numdesc;
1393   if(count>0)
1394     {
1395       int i;
1396
1397       /* Try to handle preferred keyserver keys first */
1398       for(i=0;i<numdesc;i++)
1399         {
1400           if(desc[i].skipfncvalue)
1401             {
1402               struct keyserver_spec *keyserver=desc[i].skipfncvalue;
1403
1404               if (!opt.quiet)
1405                 log_info (_("refreshing %d key from %s\n"), 1, keyserver->uri);
1406
1407               /* We use the keyserver structure we parsed out before.
1408                  Note that a preferred keyserver without a scheme://
1409                  will be interpreted as hkp:// */
1410               err = keyserver_get (ctrl, &desc[i], 1, keyserver, 0, NULL, NULL);
1411               if (err)
1412                 log_info(_("WARNING: unable to refresh key %s"
1413                            " via %s: %s\n"),keystr_from_desc(&desc[i]),
1414                          keyserver->uri,gpg_strerror (err));
1415               else
1416                 {
1417                   /* We got it, so mark it as NONE so we don't try and
1418                      get it again from the regular keyserver. */
1419
1420                   desc[i].mode=KEYDB_SEARCH_MODE_NONE;
1421                   count--;
1422                 }
1423
1424               free_keyserver_spec(keyserver);
1425             }
1426         }
1427     }
1428
1429   if(count>0)
1430     {
1431       char *tmpuri;
1432
1433       err = gpg_dirmngr_ks_list (ctrl, &tmpuri);
1434       if (!err)
1435         {
1436           if (!opt.quiet)
1437             {
1438               log_info (ngettext("refreshing %d key from %s\n",
1439                                  "refreshing %d keys from %s\n",
1440                                  count), count, tmpuri);
1441             }
1442           xfree (tmpuri);
1443
1444           err = keyserver_get (ctrl, desc, numdesc, NULL, 0, NULL, NULL);
1445         }
1446     }
1447
1448   xfree(desc);
1449
1450   opt.keyserver_options.import_options=options;
1451
1452   /* If the original options didn't have fast import, and the trustdb
1453      is dirty, rebuild. */
1454   if(!(opt.keyserver_options.import_options&IMPORT_FAST))
1455     check_or_update_trustdb (ctrl);
1456
1457   return err;
1458 }
1459
1460
1461 /* Search for keys on the keyservers.  The patterns are given in the
1462    string list TOKENS.  */
1463 gpg_error_t
1464 keyserver_search (ctrl_t ctrl, strlist_t tokens)
1465 {
1466   gpg_error_t err;
1467   char *searchstr;
1468   struct search_line_handler_parm_s parm;
1469
1470   memset (&parm, 0, sizeof parm);
1471
1472   if (!tokens)
1473     return 0;  /* Return success if no patterns are given.  */
1474
1475   /* Write global options */
1476
1477   /* for(temp=opt.keyserver_options.other;temp;temp=temp->next) */
1478   /*   es_fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
1479
1480   /* Write per-keyserver options */
1481
1482   /* for(temp=keyserver->options;temp;temp=temp->next) */
1483   /*   es_fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
1484
1485   {
1486     membuf_t mb;
1487     strlist_t item;
1488
1489     init_membuf (&mb, 1024);
1490     for (item = tokens; item; item = item->next)
1491     {
1492       if (item != tokens)
1493         put_membuf (&mb, " ", 1);
1494       put_membuf_str (&mb, item->d);
1495     }
1496     put_membuf (&mb, "", 1); /* Append Nul.  */
1497     searchstr = get_membuf (&mb, NULL);
1498     if (!searchstr)
1499       {
1500         err = gpg_error_from_syserror ();
1501         goto leave;
1502       }
1503   }
1504   /* FIXME: Enable the next line */
1505   /* log_info (_("searching for \"%s\" from %s\n"), searchstr, keyserver->uri); */
1506
1507   parm.ctrl = ctrl;
1508   if (searchstr)
1509     parm.searchstr_disp = utf8_to_native (searchstr, strlen (searchstr), 0);
1510
1511   err = gpg_dirmngr_ks_search (ctrl, searchstr, search_line_handler, &parm);
1512
1513   if (parm.not_found || gpg_err_code (err) == GPG_ERR_NO_DATA)
1514     {
1515       if (parm.searchstr_disp)
1516         log_info (_("key \"%s\" not found on keyserver\n"),
1517                   parm.searchstr_disp);
1518       else
1519         log_info (_("key not found on keyserver\n"));
1520     }
1521
1522   if (gpg_err_code (err) == GPG_ERR_NO_KEYSERVER)
1523     log_error (_("no keyserver known (use option --keyserver)\n"));
1524   else if (gpg_err_code (err) == GPG_ERR_NO_DATA)
1525     err = gpg_error (GPG_ERR_NOT_FOUND);
1526   else if (err)
1527     log_error ("error searching keyserver: %s\n", gpg_strerror (err));
1528
1529   /* switch(ret) */
1530   /*   { */
1531   /*   case KEYSERVER_SCHEME_NOT_FOUND: */
1532   /*     log_error(_("no handler for keyserver scheme '%s'\n"), */
1533   /*        opt.keyserver->scheme); */
1534   /*     break; */
1535
1536   /*   case KEYSERVER_NOT_SUPPORTED: */
1537   /*     log_error(_("action '%s' not supported with keyserver " */
1538   /*          "scheme '%s'\n"), "search", opt.keyserver->scheme); */
1539   /*     break; */
1540
1541   /*   case KEYSERVER_TIMEOUT: */
1542   /*     log_error(_("keyserver timed out\n")); */
1543   /*     break; */
1544
1545   /*   case KEYSERVER_INTERNAL_ERROR: */
1546   /*   default: */
1547   /*     log_error(_("keyserver internal error\n")); */
1548   /*     break; */
1549   /*   } */
1550
1551   /* return gpg_error (GPG_ERR_KEYSERVER); */
1552
1553
1554  leave:
1555   xfree (parm.desc);
1556   xfree (parm.searchstr_disp);
1557   xfree(searchstr);
1558
1559   return err;
1560 }
1561
1562 /* Helper for keyserver_get.  Here we only receive a chunk of the
1563    description to be processed in one batch.  This is required due to
1564    the limited number of patterns the dirmngr interface (KS_GET) can
1565    grok and to limit the amount of temporary required memory.  */
1566 static gpg_error_t
1567 keyserver_get_chunk (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
1568                      int *r_ndesc_used,
1569                      import_stats_t stats_handle,
1570                      struct keyserver_spec *override_keyserver,
1571                      int quick,
1572                      unsigned char **r_fpr, size_t *r_fprlen)
1573
1574 {
1575   gpg_error_t err = 0;
1576   char **pattern;
1577   int idx, npat, npat_fpr;
1578   estream_t datastream;
1579   char *source = NULL;
1580   size_t linelen;  /* Estimated linelen for KS_GET.  */
1581   size_t n;
1582   int only_fprs;
1583
1584 #define MAX_KS_GET_LINELEN 950  /* Somewhat lower than the real limit.  */
1585
1586   *r_ndesc_used = 0;
1587
1588   /* Create an array filled with a search pattern for each key.  The
1589      array is delimited by a NULL entry.  */
1590   pattern = xtrycalloc (ndesc+1, sizeof *pattern);
1591   if (!pattern)
1592     return gpg_error_from_syserror ();
1593
1594   /* Note that we break the loop as soon as our estimation of the to
1595      be used line length reaches the limit.  But we do this only if we
1596      have processed at least one search requests so that an overlong
1597      single request will be rejected only later by gpg_dirmngr_ks_get
1598      but we are sure that R_NDESC_USED has been updated.  This avoids
1599      a possible indefinite loop.  */
1600   linelen = 17; /* "KS_GET --quick --" */
1601   for (npat=npat_fpr=0, idx=0; idx < ndesc; idx++)
1602     {
1603       int quiet = 0;
1604
1605       if (desc[idx].mode == KEYDB_SEARCH_MODE_FPR)
1606         {
1607           n = 1+2+2*desc[idx].fprlen;
1608           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1609             break; /* Declare end of this chunk.  */
1610           linelen += n;
1611
1612           pattern[npat] = xtrymalloc (n);
1613           if (!pattern[npat])
1614             err = gpg_error_from_syserror ();
1615           else
1616             {
1617               strcpy (pattern[npat], "0x");
1618               bin2hex (desc[idx].u.fpr, desc[idx].fprlen, pattern[npat]+2);
1619               npat++;
1620               if (desc[idx].fprlen == 20 || desc[idx].fprlen == 32)
1621                 npat_fpr++;
1622             }
1623         }
1624       else if(desc[idx].mode == KEYDB_SEARCH_MODE_LONG_KID)
1625         {
1626           n = 1+2+16;
1627           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1628             break; /* Declare end of this chunk.  */
1629           linelen += n;
1630
1631           pattern[npat] = xtryasprintf ("0x%08lX%08lX",
1632                                         (ulong)desc[idx].u.kid[0],
1633                                         (ulong)desc[idx].u.kid[1]);
1634           if (!pattern[npat])
1635             err = gpg_error_from_syserror ();
1636           else
1637             npat++;
1638         }
1639       else if(desc[idx].mode == KEYDB_SEARCH_MODE_SHORT_KID)
1640         {
1641           n = 1+2+8;
1642           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1643             break; /* Declare end of this chunk.  */
1644           linelen += n;
1645
1646           pattern[npat] = xtryasprintf ("0x%08lX", (ulong)desc[idx].u.kid[1]);
1647           if (!pattern[npat])
1648             err = gpg_error_from_syserror ();
1649           else
1650             npat++;
1651         }
1652       else if(desc[idx].mode == KEYDB_SEARCH_MODE_EXACT)
1653         {
1654           /* The Dirmngr also uses classify_user_id to detect the type
1655              of the search string.  By adding the '=' prefix we force
1656              Dirmngr's KS_GET to consider this an exact search string.
1657              (In gpg 1.4 and gpg 2.0 the keyserver helpers used the
1658              KS_GETNAME command to indicate this.)  */
1659
1660           n = 1+1+strlen (desc[idx].u.name);
1661           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1662             break; /* Declare end of this chunk.  */
1663           linelen += n;
1664
1665           pattern[npat] = strconcat ("=", desc[idx].u.name, NULL);
1666           if (!pattern[npat])
1667             err = gpg_error_from_syserror ();
1668           else
1669             {
1670               npat++;
1671               quiet = 1;
1672             }
1673         }
1674       else if (desc[idx].mode == KEYDB_SEARCH_MODE_NONE)
1675         continue;
1676       else
1677         BUG();
1678
1679       if (err)
1680         {
1681           for (idx=0; idx < npat; idx++)
1682             xfree (pattern[idx]);
1683           xfree (pattern);
1684           return err;
1685         }
1686
1687       if (!quiet && override_keyserver)
1688         {
1689           if (override_keyserver->host)
1690             log_info (_("requesting key %s from %s server %s\n"),
1691                       keystr_from_desc (&desc[idx]),
1692                       override_keyserver->scheme, override_keyserver->host);
1693           else
1694             log_info (_("requesting key %s from %s\n"),
1695                       keystr_from_desc (&desc[idx]), override_keyserver->uri);
1696         }
1697     }
1698
1699   /* Remember how many of the search items were considered.  Note that
1700      this is different from NPAT.  */
1701   *r_ndesc_used = idx;
1702
1703   only_fprs = (npat && npat == npat_fpr);
1704
1705   err = gpg_dirmngr_ks_get (ctrl, pattern, override_keyserver, quick,
1706                             &datastream, &source);
1707   for (idx=0; idx < npat; idx++)
1708     xfree (pattern[idx]);
1709   xfree (pattern);
1710   if (opt.verbose && source)
1711     log_info ("data source: %s\n", source);
1712
1713   if (!err)
1714     {
1715       struct ks_retrieval_screener_arg_s screenerarg;
1716
1717       /* FIXME: Check whether this comment should be moved to dirmngr.
1718
1719          Slurp up all the key data.  In the future, it might be nice
1720          to look for KEY foo OUTOFBAND and FAILED indicators.  It's
1721          harmless to ignore them, but ignoring them does make gpg
1722          complain about "no valid OpenPGP data found".  One way to do
1723          this could be to continue parsing this line-by-line and make
1724          a temp iobuf for each key.  Note that we don't allow the
1725          import of secret keys from a keyserver.  Keyservers should
1726          never accept or send them but we better protect against rogue
1727          keyservers. */
1728
1729       screenerarg.desc = desc;
1730       screenerarg.ndesc = *r_ndesc_used;
1731       import_keys_es_stream (ctrl, datastream, stats_handle,
1732                              r_fpr, r_fprlen,
1733                              (opt.keyserver_options.import_options
1734                               | IMPORT_NO_SECKEY),
1735                              keyserver_retrieval_screener, &screenerarg,
1736                              only_fprs? KEYORG_KS : 0,
1737                              source);
1738     }
1739   es_fclose (datastream);
1740   xfree (source);
1741
1742   return err;
1743 }
1744
1745
1746 /* Retrieve a key from a keyserver.  The search pattern are in
1747    (DESC,NDESC).  Allowed search modes are keyid, fingerprint, and
1748    exact searches.  OVERRIDE_KEYSERVER gives an optional override
1749    keyserver. If (R_FPR,R_FPRLEN) are not NULL, they may return the
1750    fingerprint of a single imported key.  If QUICK is set, dirmngr is
1751    advised to use a shorter timeout. */
1752 static gpg_error_t
1753 keyserver_get (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
1754                struct keyserver_spec *override_keyserver, int quick,
1755                unsigned char **r_fpr, size_t *r_fprlen)
1756 {
1757   gpg_error_t err;
1758   import_stats_t stats_handle;
1759   int ndesc_used;
1760   int any_good = 0;
1761
1762   stats_handle = import_new_stats_handle();
1763
1764   for (;;)
1765     {
1766       err = keyserver_get_chunk (ctrl, desc, ndesc, &ndesc_used, stats_handle,
1767                                  override_keyserver, quick, r_fpr, r_fprlen);
1768       if (!err)
1769         any_good = 1;
1770       if (err || ndesc_used >= ndesc)
1771         break; /* Error or all processed.  */
1772       /* Prepare for the next chunk.  */
1773       desc += ndesc_used;
1774       ndesc -= ndesc_used;
1775     }
1776
1777   if (any_good)
1778     import_print_stats (stats_handle);
1779
1780   import_release_stats_handle (stats_handle);
1781   return err;
1782 }
1783
1784
1785 /* Send all keys specified by KEYSPECS to the configured keyserver.  */
1786 static gpg_error_t
1787 keyserver_put (ctrl_t ctrl, strlist_t keyspecs)
1788
1789 {
1790   gpg_error_t err;
1791   strlist_t kspec;
1792   char *ksurl;
1793
1794   if (!keyspecs)
1795     return 0;  /* Return success if the list is empty.  */
1796
1797   if (gpg_dirmngr_ks_list (ctrl, &ksurl))
1798     {
1799       log_error (_("no keyserver known\n"));
1800       return gpg_error (GPG_ERR_NO_KEYSERVER);
1801     }
1802
1803   for (kspec = keyspecs; kspec; kspec = kspec->next)
1804     {
1805       void *data;
1806       size_t datalen;
1807       kbnode_t keyblock;
1808
1809       err = export_pubkey_buffer (ctrl, kspec->d,
1810                                   opt.keyserver_options.export_options,
1811                                   NULL,
1812                                   &keyblock, &data, &datalen);
1813       if (err)
1814         log_error (_("skipped \"%s\": %s\n"), kspec->d, gpg_strerror (err));
1815       else
1816         {
1817           log_info (_("sending key %s to %s\n"),
1818                     keystr (keyblock->pkt->pkt.public_key->keyid),
1819                     ksurl?ksurl:"[?]");
1820
1821           err = gpg_dirmngr_ks_put (ctrl, data, datalen, keyblock);
1822           release_kbnode (keyblock);
1823           xfree (data);
1824           if (err)
1825             {
1826               write_status_error ("keyserver_send", err);
1827               log_error (_("keyserver send failed: %s\n"), gpg_strerror (err));
1828             }
1829         }
1830     }
1831
1832   xfree (ksurl);
1833
1834   return err;
1835
1836 }
1837
1838
1839 /* Loop over all URLs in STRLIST and fetch the key at that URL.  Note
1840    that the fetch operation ignores the configured keyservers and
1841    instead directly retrieves the keys.  */
1842 int
1843 keyserver_fetch (ctrl_t ctrl, strlist_t urilist, int origin)
1844 {
1845   gpg_error_t err;
1846   strlist_t sl;
1847   estream_t datastream;
1848   unsigned int save_options = opt.keyserver_options.import_options;
1849
1850   /* Switch on fast-import, since fetch can handle more than one
1851      import and we don't want each set to rebuild the trustdb.
1852      Instead we do it once at the end. */
1853   opt.keyserver_options.import_options |= IMPORT_FAST;
1854
1855   for (sl=urilist; sl; sl=sl->next)
1856     {
1857       if (!opt.quiet)
1858         log_info (_("requesting key from '%s'\n"), sl->d);
1859
1860       err = gpg_dirmngr_ks_fetch (ctrl, sl->d, &datastream);
1861       if (!err)
1862         {
1863           import_stats_t stats_handle;
1864
1865           stats_handle = import_new_stats_handle();
1866           import_keys_es_stream (ctrl, datastream, stats_handle, NULL, NULL,
1867                                  opt.keyserver_options.import_options,
1868                                  NULL, NULL, origin, sl->d);
1869
1870           import_print_stats (stats_handle);
1871           import_release_stats_handle (stats_handle);
1872         }
1873       else
1874         log_info (_("WARNING: unable to fetch URI %s: %s\n"),
1875                   sl->d, gpg_strerror (err));
1876       es_fclose (datastream);
1877     }
1878
1879   opt.keyserver_options.import_options = save_options;
1880
1881   /* If the original options didn't have fast import, and the trustdb
1882      is dirty, rebuild. */
1883   if (!(opt.keyserver_options.import_options&IMPORT_FAST))
1884     check_or_update_trustdb (ctrl);
1885
1886   return 0;
1887 }
1888
1889
1890 /* Import key in a CERT or pointed to by a CERT.  In DANE_MODE fetch
1891    the certificate using the DANE method.  */
1892 int
1893 keyserver_import_cert (ctrl_t ctrl, const char *name, int dane_mode,
1894                        unsigned char **fpr,size_t *fpr_len)
1895 {
1896   gpg_error_t err;
1897   char *look,*url;
1898   estream_t key;
1899
1900   look = xstrdup(name);
1901
1902   if (!dane_mode)
1903     {
1904       char *domain = strrchr (look,'@');
1905       if (domain)
1906         *domain='.';
1907     }
1908
1909   err = gpg_dirmngr_dns_cert (ctrl, look, dane_mode? NULL : "*",
1910                               &key, fpr, fpr_len, &url);
1911   if (err)
1912     ;
1913   else if (key)
1914     {
1915       int armor_status=opt.no_armor;
1916       import_filter_t save_filt;
1917
1918       /* CERTs and DANE records are always in binary format */
1919       opt.no_armor=1;
1920       if (dane_mode)
1921         {
1922           save_filt = save_and_clear_import_filter ();
1923           if (!save_filt)
1924             err = gpg_error_from_syserror ();
1925           else
1926             {
1927               char *filtstr = es_bsprintf ("keep-uid=mbox = %s", look);
1928               err = filtstr? 0 : gpg_error_from_syserror ();
1929               if (!err)
1930                 err = parse_and_set_import_filter (filtstr);
1931               xfree (filtstr);
1932               if (!err)
1933                 err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
1934                                              IMPORT_NO_SECKEY,
1935                                              NULL, NULL, KEYORG_DANE, NULL);
1936               restore_import_filter (save_filt);
1937             }
1938         }
1939       else
1940         {
1941           err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
1942                                        (opt.keyserver_options.import_options
1943                                         | IMPORT_NO_SECKEY),
1944                                        NULL, NULL, 0, NULL);
1945         }
1946
1947       opt.no_armor=armor_status;
1948
1949       es_fclose (key);
1950       key = NULL;
1951     }
1952   else if (*fpr)
1953     {
1954       /* We only consider the IPGP type if a fingerprint was provided.
1955          This lets us select the right key regardless of what a URL
1956          points to, or get the key from a keyserver. */
1957       if(url)
1958         {
1959           struct keyserver_spec *spec;
1960
1961           spec = parse_keyserver_uri (url, 1);
1962           if(spec)
1963             {
1964               err = keyserver_import_fprint (ctrl, *fpr, *fpr_len, spec, 0);
1965               free_keyserver_spec(spec);
1966             }
1967         }
1968       else if (keyserver_any_configured (ctrl))
1969         {
1970           /* If only a fingerprint is provided, try and fetch it from
1971              the configured keyserver. */
1972
1973           err = keyserver_import_fprint (ctrl,
1974                                          *fpr, *fpr_len, opt.keyserver, 0);
1975         }
1976       else
1977         log_info(_("no keyserver known\n"));
1978
1979       /* Give a better string here? "CERT fingerprint for \"%s\"
1980          found, but no keyserver" " known (use option
1981          --keyserver)\n" ? */
1982
1983     }
1984
1985   xfree(url);
1986   xfree(look);
1987
1988   return err;
1989 }
1990
1991 /* Import key pointed to by a PKA record. Return the requested
1992    fingerprint in fpr. */
1993 gpg_error_t
1994 keyserver_import_pka (ctrl_t ctrl, const char *name,
1995                       unsigned char **fpr, size_t *fpr_len)
1996 {
1997   gpg_error_t err;
1998   char *url;
1999
2000   err = gpg_dirmngr_get_pka (ctrl, name, fpr, fpr_len, &url);
2001   if (url && *url && fpr && fpr_len)
2002     {
2003       /* An URL is available.  Lookup the key. */
2004       struct keyserver_spec *spec;
2005       spec = parse_keyserver_uri (url, 1);
2006       if (spec)
2007         {
2008           err = keyserver_import_fprint (ctrl, *fpr, *fpr_len, spec, 0);
2009           free_keyserver_spec (spec);
2010         }
2011     }
2012   xfree (url);
2013
2014   if (err)
2015     {
2016       xfree(*fpr);
2017       *fpr = NULL;
2018       *fpr_len = 0;
2019     }
2020
2021   return err;
2022 }
2023
2024
2025 /* Import a key using the Web Key Directory protocol.  */
2026 gpg_error_t
2027 keyserver_import_wkd (ctrl_t ctrl, const char *name, int quick,
2028                       unsigned char **fpr, size_t *fpr_len)
2029 {
2030   gpg_error_t err;
2031   char *mbox;
2032   estream_t key;
2033   char *url = NULL;
2034
2035   /* We want to work on the mbox.  That is what dirmngr will do anyway
2036    * and we need the mbox for the import filter anyway.  */
2037   mbox = mailbox_from_userid (name, 0);
2038   if (!mbox)
2039     {
2040       err = gpg_error_from_syserror ();
2041       if (gpg_err_code (err) == GPG_ERR_EINVAL)
2042         err = gpg_error (GPG_ERR_INV_USER_ID);
2043       return err;
2044     }
2045
2046   err = gpg_dirmngr_wkd_get (ctrl, mbox, quick, &key, &url);
2047   if (err)
2048     ;
2049   else if (key)
2050     {
2051       int armor_status = opt.no_armor;
2052       import_filter_t save_filt;
2053
2054       /* Keys returned via WKD are in binary format.  However, we
2055        * relax that requirement and allow also for armored data.  */
2056       opt.no_armor = 0;
2057       save_filt = save_and_clear_import_filter ();
2058       if (!save_filt)
2059         err = gpg_error_from_syserror ();
2060       else
2061         {
2062           char *filtstr = es_bsprintf ("keep-uid=mbox = %s", mbox);
2063           err = filtstr? 0 : gpg_error_from_syserror ();
2064           if (!err)
2065             err = parse_and_set_import_filter (filtstr);
2066           xfree (filtstr);
2067           if (!err)
2068             err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
2069                                          IMPORT_NO_SECKEY,
2070                                          NULL, NULL, KEYORG_WKD, url);
2071
2072         }
2073
2074       restore_import_filter (save_filt);
2075       opt.no_armor = armor_status;
2076
2077       es_fclose (key);
2078       key = NULL;
2079     }
2080
2081   xfree (url);
2082   xfree (mbox);
2083   return err;
2084 }
2085
2086
2087 /* Import a key by name using LDAP */
2088 int
2089 keyserver_import_ldap (ctrl_t ctrl,
2090                        const char *name, unsigned char **fpr, size_t *fprlen)
2091 {
2092   (void)ctrl;
2093   (void)name;
2094   (void)fpr;
2095   (void)fprlen;
2096   return gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
2097 #if 0
2098   char *domain;
2099   struct keyserver_spec *keyserver;
2100   strlist_t list=NULL;
2101   int rc,hostlen=1;
2102   struct srventry *srvlist=NULL;
2103   int srvcount,i;
2104   char srvname[MAXDNAME];
2105
2106   /* Parse out the domain */
2107   domain=strrchr(name,'@');
2108   if(!domain)
2109     return GPG_ERR_GENERAL;
2110
2111   domain++;
2112
2113   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
2114   keyserver->scheme=xstrdup("ldap");
2115   keyserver->host=xmalloc(1);
2116   keyserver->host[0]='\0';
2117
2118   snprintf(srvname,MAXDNAME,"_pgpkey-ldap._tcp.%s",domain);
2119
2120   FIXME("network related - move to dirmngr or drop the code");
2121   srvcount=getsrv(srvname,&srvlist);
2122
2123   for(i=0;i<srvcount;i++)
2124     {
2125       hostlen+=strlen(srvlist[i].target)+1;
2126       keyserver->host=xrealloc(keyserver->host,hostlen);
2127
2128       strcat(keyserver->host,srvlist[i].target);
2129
2130       if(srvlist[i].port!=389)
2131         {
2132           char port[7];
2133
2134           hostlen+=6; /* a colon, plus 5 digits (unsigned 16-bit value) */
2135           keyserver->host=xrealloc(keyserver->host,hostlen);
2136
2137           snprintf(port,7,":%u",srvlist[i].port);
2138           strcat(keyserver->host,port);
2139         }
2140
2141       strcat(keyserver->host," ");
2142     }
2143
2144   free(srvlist);
2145
2146   /* If all else fails, do the PGP Universal trick of
2147      ldap://keys.(domain) */
2148
2149   hostlen+=5+strlen(domain);
2150   keyserver->host=xrealloc(keyserver->host,hostlen);
2151   strcat(keyserver->host,"keys.");
2152   strcat(keyserver->host,domain);
2153
2154   append_to_strlist(&list,name);
2155
2156   rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
2157        /* keyserver_work (ctrl, KS_GETNAME, list, NULL, */
2158        /*                 0, fpr, fpr_len, keyserver); */
2159
2160   free_strlist(list);
2161
2162   free_keyserver_spec(keyserver);
2163
2164   return rc;
2165 #endif
2166 }