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