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