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