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