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