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