Use ngettext for some strings.
[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 %d key from %s\n"), 1, 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               log_info (ngettext("refreshing %d key from %s\n",
1440                                  "refreshing %d keys from %s\n",
1441                                  count), count, tmpuri);
1442             }
1443           xfree (tmpuri);
1444
1445           err = keyserver_get (ctrl, desc, numdesc, NULL, NULL, NULL);
1446         }
1447     }
1448
1449   xfree(desc);
1450
1451   opt.keyserver_options.import_options=options;
1452
1453   /* If the original options didn't have fast import, and the trustdb
1454      is dirty, rebuild. */
1455   if(!(opt.keyserver_options.import_options&IMPORT_FAST))
1456     check_or_update_trustdb ();
1457
1458   return err;
1459 }
1460
1461
1462 /* Search for keys on the keyservers.  The patterns are given in the
1463    string list TOKENS.  */
1464 gpg_error_t
1465 keyserver_search (ctrl_t ctrl, strlist_t tokens)
1466 {
1467   gpg_error_t err;
1468   char *searchstr;
1469   struct search_line_handler_parm_s parm;
1470
1471   memset (&parm, 0, sizeof parm);
1472
1473   if (!tokens)
1474     return 0;  /* Return success if no patterns are given.  */
1475
1476   /* Write global options */
1477
1478   /* for(temp=opt.keyserver_options.other;temp;temp=temp->next) */
1479   /*   es_fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
1480
1481   /* Write per-keyserver options */
1482
1483   /* for(temp=keyserver->options;temp;temp=temp->next) */
1484   /*   es_fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
1485
1486   {
1487     membuf_t mb;
1488     strlist_t item;
1489
1490     init_membuf (&mb, 1024);
1491     for (item = tokens; item; item = item->next)
1492     {
1493       if (item != tokens)
1494         put_membuf (&mb, " ", 1);
1495       put_membuf_str (&mb, item->d);
1496     }
1497     put_membuf (&mb, "", 1); /* Append Nul.  */
1498     searchstr = get_membuf (&mb, NULL);
1499     if (!searchstr)
1500       {
1501         err = gpg_error_from_syserror ();
1502         goto leave;
1503       }
1504   }
1505   /* FIXME: Enable the next line */
1506   /* log_info (_("searching for \"%s\" from %s\n"), searchstr, keyserver->uri); */
1507
1508   parm.ctrl = ctrl;
1509   if (searchstr)
1510     parm.searchstr_disp = utf8_to_native (searchstr, strlen (searchstr), 0);
1511
1512   err = gpg_dirmngr_ks_search (ctrl, searchstr, search_line_handler, &parm);
1513
1514   if (parm.not_found)
1515     {
1516       if (parm.searchstr_disp)
1517         log_info (_("key \"%s\" not found on keyserver\n"),
1518                   parm.searchstr_disp);
1519       else
1520         log_info (_("key not found on keyserver\n"));
1521     }
1522
1523   if (gpg_err_code (err) == GPG_ERR_NO_KEYSERVER)
1524     log_error (_("no keyserver known (use option --keyserver)\n"));
1525   else if (err)
1526     log_error ("error searching keyserver: %s\n", gpg_strerror (err));
1527
1528   /* switch(ret) */
1529   /*   { */
1530   /*   case KEYSERVER_SCHEME_NOT_FOUND: */
1531   /*     log_error(_("no handler for keyserver scheme '%s'\n"), */
1532   /*        opt.keyserver->scheme); */
1533   /*     break; */
1534
1535   /*   case KEYSERVER_NOT_SUPPORTED: */
1536   /*     log_error(_("action '%s' not supported with keyserver " */
1537   /*          "scheme '%s'\n"), "search", opt.keyserver->scheme); */
1538   /*     break; */
1539
1540   /*   case KEYSERVER_TIMEOUT: */
1541   /*     log_error(_("keyserver timed out\n")); */
1542   /*     break; */
1543
1544   /*   case KEYSERVER_INTERNAL_ERROR: */
1545   /*   default: */
1546   /*     log_error(_("keyserver internal error\n")); */
1547   /*     break; */
1548   /*   } */
1549
1550   /* return gpg_error (GPG_ERR_KEYSERVER); */
1551
1552
1553  leave:
1554   xfree (parm.desc);
1555   xfree (parm.searchstr_disp);
1556   xfree(searchstr);
1557
1558   return err;
1559 }
1560
1561 /* Helper for keyserver_get.  Here we only receive a chunk of the
1562    description to be processed in one batch.  This is required due to
1563    the limited number of patterns the dirmngr interface (KS_GET) can
1564    grok and to limit the amount of temporary required memory.  */
1565 static gpg_error_t
1566 keyserver_get_chunk (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
1567                      int *r_ndesc_used,
1568                      import_stats_t stats_handle,
1569                      struct keyserver_spec *override_keyserver,
1570                      unsigned char **r_fpr, size_t *r_fprlen)
1571
1572 {
1573   gpg_error_t err = 0;
1574   char **pattern;
1575   int idx, npat;
1576   estream_t datastream;
1577   char *source = NULL;
1578   size_t linelen;  /* Estimated linelen for KS_GET.  */
1579   size_t n;
1580
1581 #define MAX_KS_GET_LINELEN 950  /* Somewhat lower than the real limit.  */
1582
1583   *r_ndesc_used = 0;
1584
1585   /* Create an array filled with a search pattern for each key.  The
1586      array is delimited by a NULL entry.  */
1587   pattern = xtrycalloc (ndesc+1, sizeof *pattern);
1588   if (!pattern)
1589     return gpg_error_from_syserror ();
1590
1591   /* Note that we break the loop as soon as our estimation of the to
1592      be used line length reaches the limit.  But we do this only if we
1593      have processed at leas one search requests so that an overlong
1594      single request will be rejected only later by gpg_dirmngr_ks_get
1595      but we are sure that R_NDESC_USED has been updated.  This avoids
1596      a possible indefinite loop.  */
1597   linelen = 9; /* "KS_GET --" */
1598   for (npat=idx=0; idx < ndesc; idx++)
1599     {
1600       int quiet = 0;
1601
1602       if (desc[idx].mode == KEYDB_SEARCH_MODE_FPR20
1603           || desc[idx].mode == KEYDB_SEARCH_MODE_FPR16)
1604         {
1605           n = 1+2+2*20;
1606           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1607             break; /* Declare end of this chunk.  */
1608           linelen += n;
1609
1610           pattern[npat] = xtrymalloc (n);
1611           if (!pattern[npat])
1612             err = gpg_error_from_syserror ();
1613           else
1614             {
1615               strcpy (pattern[npat], "0x");
1616               bin2hex (desc[idx].u.fpr,
1617                        desc[idx].mode == KEYDB_SEARCH_MODE_FPR20? 20 : 16,
1618                        pattern[npat]+2);
1619               npat++;
1620             }
1621         }
1622       else if(desc[idx].mode == KEYDB_SEARCH_MODE_LONG_KID)
1623         {
1624           n = 1+2+16;
1625           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1626             break; /* Declare end of this chunk.  */
1627           linelen += n;
1628
1629           pattern[npat] = xtryasprintf ("0x%08lX%08lX",
1630                                         (ulong)desc[idx].u.kid[0],
1631                                         (ulong)desc[idx].u.kid[1]);
1632           if (!pattern[npat])
1633             err = gpg_error_from_syserror ();
1634           else
1635             npat++;
1636         }
1637       else if(desc[idx].mode == KEYDB_SEARCH_MODE_SHORT_KID)
1638         {
1639           n = 1+2+8;
1640           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1641             break; /* Declare end of this chunk.  */
1642           linelen += n;
1643
1644           pattern[npat] = xtryasprintf ("0x%08lX", (ulong)desc[idx].u.kid[1]);
1645           if (!pattern[npat])
1646             err = gpg_error_from_syserror ();
1647           else
1648             npat++;
1649         }
1650       else if(desc[idx].mode == KEYDB_SEARCH_MODE_EXACT)
1651         {
1652           /* The Dirmngr also uses classify_user_id to detect the type
1653              of the search string.  By adding the '=' prefix we force
1654              Dirmngr's KS_GET to consider this an exact search string.
1655              (In gpg 1.4 and gpg 2.0 the keyserver helpers used the
1656              KS_GETNAME command to indicate this.)  */
1657
1658           n = 1+1+strlen (desc[idx].u.name);
1659           if (idx && linelen + n > MAX_KS_GET_LINELEN)
1660             break; /* Declare end of this chunk.  */
1661           linelen += n;
1662
1663           pattern[npat] = strconcat ("=", desc[idx].u.name, NULL);
1664           if (!pattern[npat])
1665             err = gpg_error_from_syserror ();
1666           else
1667             {
1668               npat++;
1669               quiet = 1;
1670             }
1671         }
1672       else if (desc[idx].mode == KEYDB_SEARCH_MODE_NONE)
1673         continue;
1674       else
1675         BUG();
1676
1677       if (err)
1678         {
1679           for (idx=0; idx < npat; idx++)
1680             xfree (pattern[idx]);
1681           xfree (pattern);
1682           return err;
1683         }
1684
1685       if (!quiet && override_keyserver)
1686         {
1687           if (override_keyserver->host)
1688             log_info (_("requesting key %s from %s server %s\n"),
1689                       keystr_from_desc (&desc[idx]),
1690                       override_keyserver->scheme, override_keyserver->host);
1691           else
1692             log_info (_("requesting key %s from %s\n"),
1693                       keystr_from_desc (&desc[idx]), override_keyserver->uri);
1694         }
1695     }
1696
1697   /* Remember now many of search items were considered.  Note that
1698      this is different from NPAT.  */
1699   *r_ndesc_used = idx;
1700
1701   err = gpg_dirmngr_ks_get (ctrl, pattern, override_keyserver,
1702                             &datastream, &source);
1703   for (idx=0; idx < npat; idx++)
1704     xfree (pattern[idx]);
1705   xfree (pattern);
1706   if (opt.verbose && source)
1707     log_info ("data source: %s\n", source);
1708
1709   if (!err)
1710     {
1711       struct ks_retrieval_screener_arg_s screenerarg;
1712
1713       /* FIXME: Check whether this comment should be moved to dirmngr.
1714
1715          Slurp up all the key data.  In the future, it might be nice
1716          to look for KEY foo OUTOFBAND and FAILED indicators.  It's
1717          harmless to ignore them, but ignoring them does make gpg
1718          complain about "no valid OpenPGP data found".  One way to do
1719          this could be to continue parsing this line-by-line and make
1720          a temp iobuf for each key.  Note that we don't allow the
1721          import of secret keys from a keyserver.  Keyservers should
1722          never accept or send them but we better protect against rogue
1723          keyservers. */
1724
1725       screenerarg.desc = desc;
1726       screenerarg.ndesc = *r_ndesc_used;
1727       import_keys_es_stream (ctrl, datastream, stats_handle,
1728                              r_fpr, r_fprlen,
1729                              (opt.keyserver_options.import_options
1730                               | IMPORT_NO_SECKEY),
1731                              keyserver_retrieval_screener, &screenerarg);
1732     }
1733   es_fclose (datastream);
1734   xfree (source);
1735
1736   return err;
1737 }
1738
1739
1740 /* Retrieve a key from a keyserver.  The search pattern are in
1741    (DESC,NDESC).  Allowed search modes are keyid, fingerprint, and
1742    exact searches.  OVERRIDE_KEYSERVER gives an optional override
1743    keyserver. If (R_FPR,R_FPRLEN) are not NULL, they may return the
1744    fingerprint of a single imported key.  */
1745 static gpg_error_t
1746 keyserver_get (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
1747                struct keyserver_spec *override_keyserver,
1748                unsigned char **r_fpr, size_t *r_fprlen)
1749 {
1750   gpg_error_t err;
1751   import_stats_t stats_handle;
1752   int ndesc_used;
1753   int any_good = 0;
1754
1755   stats_handle = import_new_stats_handle();
1756
1757   for (;;)
1758     {
1759       err = keyserver_get_chunk (ctrl, desc, ndesc, &ndesc_used, stats_handle,
1760                                  override_keyserver, r_fpr, r_fprlen);
1761       if (!err)
1762         any_good = 1;
1763       if (err || ndesc_used >= ndesc)
1764         break; /* Error or all processed.  */
1765       /* Prepare for the next chunk.  */
1766       desc += ndesc_used;
1767       ndesc -= ndesc_used;
1768     }
1769
1770   if (any_good)
1771     import_print_stats (stats_handle);
1772
1773   import_release_stats_handle (stats_handle);
1774   return err;
1775 }
1776
1777
1778 /* Send all keys specified by KEYSPECS to the KEYSERVERS.  */
1779 static gpg_error_t
1780 keyserver_put (ctrl_t ctrl, strlist_t keyspecs,
1781                struct keyserver_spec *keyserver)
1782
1783 {
1784   gpg_error_t err;
1785   strlist_t kspec;
1786
1787   if (!keyspecs)
1788     return 0;  /* Return success if the list is empty.  */
1789
1790   if (!opt.keyserver)
1791     {
1792       log_error (_("no keyserver known (use option --keyserver)\n"));
1793       return gpg_error (GPG_ERR_NO_KEYSERVER);
1794     }
1795
1796   for (kspec = keyspecs; kspec; kspec = kspec->next)
1797     {
1798       void *data;
1799       size_t datalen;
1800       kbnode_t keyblock;
1801
1802       err = export_pubkey_buffer (ctrl, kspec->d,
1803                                   opt.keyserver_options.export_options,
1804                                   NULL,
1805                                   &keyblock, &data, &datalen);
1806       if (err)
1807         log_error (_("skipped \"%s\": %s\n"), kspec->d, gpg_strerror (err));
1808       else
1809         {
1810           if (keyserver->host)
1811             log_info (_("sending key %s to %s server %s\n"),
1812                       keystr (keyblock->pkt->pkt.public_key->keyid),
1813                       keyserver->scheme, keyserver->host);
1814           else
1815             log_info (_("sending key %s to %s\n"),
1816                       keystr (keyblock->pkt->pkt.public_key->keyid),
1817                       keyserver->uri);
1818
1819           err = gpg_dirmngr_ks_put (ctrl, data, datalen, keyblock);
1820           release_kbnode (keyblock);
1821           xfree (data);
1822           if (err)
1823             {
1824               write_status_error ("keyserver_send", err);
1825               log_error (_("keyserver send failed: %s\n"), gpg_strerror (err));
1826             }
1827         }
1828     }
1829
1830
1831   return err;
1832
1833 }
1834
1835
1836 /* Loop over all URLs in STRLIST and fetch the key at that URL.  Note
1837    that the fetch operation ignores the configured key servers and
1838    instead directly retrieves the keys.  */
1839 int
1840 keyserver_fetch (ctrl_t ctrl, strlist_t urilist)
1841 {
1842   gpg_error_t err;
1843   strlist_t sl;
1844   estream_t datastream;
1845   unsigned int save_options = opt.keyserver_options.import_options;
1846
1847   /* Switch on fast-import, since fetch can handle more than one
1848      import and we don't want each set to rebuild the trustdb.
1849      Instead we do it once at the end. */
1850   opt.keyserver_options.import_options |= IMPORT_FAST;
1851
1852   for (sl=urilist; sl; sl=sl->next)
1853     {
1854       if (!opt.quiet)
1855         log_info (_("requesting key from '%s'\n"), sl->d);
1856
1857       err = gpg_dirmngr_ks_fetch (ctrl, sl->d, &datastream);
1858       if (!err)
1859         {
1860           import_stats_t stats_handle;
1861
1862           stats_handle = import_new_stats_handle();
1863           import_keys_es_stream (ctrl, datastream, stats_handle, NULL, NULL,
1864                                  opt.keyserver_options.import_options,
1865                                  NULL, NULL);
1866
1867           import_print_stats (stats_handle);
1868           import_release_stats_handle (stats_handle);
1869         }
1870       else
1871         log_info (_("WARNING: unable to fetch URI %s: %s\n"),
1872                   sl->d, gpg_strerror (err));
1873       es_fclose (datastream);
1874     }
1875
1876   opt.keyserver_options.import_options = save_options;
1877
1878   /* If the original options didn't have fast import, and the trustdb
1879      is dirty, rebuild. */
1880   if (!(opt.keyserver_options.import_options&IMPORT_FAST))
1881     check_or_update_trustdb ();
1882
1883   return 0;
1884 }
1885
1886
1887 /* Import key in a CERT or pointed to by a CERT.  In DANE_MODE fetch
1888    the certificate using the DANE method.  */
1889 int
1890 keyserver_import_cert (ctrl_t ctrl, const char *name, int dane_mode,
1891                        unsigned char **fpr,size_t *fpr_len)
1892 {
1893   gpg_error_t err;
1894   char *look,*url;
1895   estream_t key;
1896
1897   look = xstrdup(name);
1898
1899   if (!dane_mode)
1900     {
1901       char *domain = strrchr (look,'@');
1902       if (domain)
1903         *domain='.';
1904     }
1905
1906   err = gpg_dirmngr_dns_cert (ctrl, look, dane_mode? NULL : "*",
1907                               &key, fpr, fpr_len, &url);
1908   if (err)
1909     ;
1910   else if (key)
1911     {
1912       int armor_status=opt.no_armor;
1913
1914       /* CERTs and DANE records are always in binary format */
1915       opt.no_armor=1;
1916
1917       err = import_keys_es_stream (ctrl, key, NULL, fpr, fpr_len,
1918                                    (opt.keyserver_options.import_options
1919                                     | IMPORT_NO_SECKEY),
1920                                    NULL, NULL);
1921
1922       opt.no_armor=armor_status;
1923
1924       es_fclose (key);
1925       key = NULL;
1926     }
1927   else if (*fpr)
1928     {
1929       /* We only consider the IPGP type if a fingerprint was provided.
1930          This lets us select the right key regardless of what a URL
1931          points to, or get the key from a keyserver. */
1932       if(url)
1933         {
1934           struct keyserver_spec *spec;
1935
1936           spec = parse_keyserver_uri (url, 1);
1937           if(spec)
1938             {
1939               err = keyserver_import_fprint (ctrl, *fpr,*fpr_len,spec);
1940               free_keyserver_spec(spec);
1941             }
1942         }
1943       else if(opt.keyserver)
1944         {
1945           /* If only a fingerprint is provided, try and fetch it from
1946              our --keyserver */
1947
1948           err = keyserver_import_fprint (ctrl, *fpr,*fpr_len,opt.keyserver);
1949         }
1950       else
1951         log_info(_("no keyserver known (use option --keyserver)\n"));
1952
1953       /* Give a better string here? "CERT fingerprint for \"%s\"
1954          found, but no keyserver" " known (use option
1955          --keyserver)\n" ? */
1956
1957     }
1958
1959   xfree(url);
1960   xfree(look);
1961
1962   return err;
1963 }
1964
1965 /* Import key pointed to by a PKA record. Return the requested
1966    fingerprint in fpr. */
1967 gpg_error_t
1968 keyserver_import_pka (ctrl_t ctrl, const char *name,
1969                       unsigned char **fpr, size_t *fpr_len)
1970 {
1971   gpg_error_t err;
1972   char *url;
1973
1974   err = gpg_dirmngr_get_pka (ctrl, name, fpr, fpr_len, &url);
1975   if (url && *url && fpr && fpr_len)
1976     {
1977       /* An URL is available.  Lookup the key. */
1978       struct keyserver_spec *spec;
1979       spec = parse_keyserver_uri (url, 1);
1980       if (spec)
1981         {
1982           err = keyserver_import_fprint (ctrl, *fpr, *fpr_len, spec);
1983           free_keyserver_spec (spec);
1984         }
1985     }
1986   xfree (url);
1987
1988   if (err)
1989     {
1990       xfree(*fpr);
1991       *fpr = NULL;
1992       *fpr_len = 0;
1993     }
1994
1995   return err;
1996 }
1997
1998
1999 /* Import a key by name using LDAP */
2000 int
2001 keyserver_import_ldap (ctrl_t ctrl,
2002                        const char *name, unsigned char **fpr, size_t *fprlen)
2003 {
2004   (void)ctrl;
2005   (void)name;
2006   (void)fpr;
2007   (void)fprlen;
2008   return gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
2009 #if 0
2010   char *domain;
2011   struct keyserver_spec *keyserver;
2012   strlist_t list=NULL;
2013   int rc,hostlen=1;
2014 #ifdef USE_DNS_SRV
2015   struct srventry *srvlist=NULL;
2016   int srvcount,i;
2017   char srvname[MAXDNAME];
2018 #endif
2019
2020   /* Parse out the domain */
2021   domain=strrchr(name,'@');
2022   if(!domain)
2023     return GPG_ERR_GENERAL;
2024
2025   domain++;
2026
2027   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
2028   keyserver->scheme=xstrdup("ldap");
2029   keyserver->host=xmalloc(1);
2030   keyserver->host[0]='\0';
2031
2032 #ifdef USE_DNS_SRV
2033   snprintf(srvname,MAXDNAME,"_pgpkey-ldap._tcp.%s",domain);
2034
2035   FIXME("network related - move to dirmngr or drop the code");
2036   srvcount=getsrv(srvname,&srvlist);
2037
2038   for(i=0;i<srvcount;i++)
2039     {
2040       hostlen+=strlen(srvlist[i].target)+1;
2041       keyserver->host=xrealloc(keyserver->host,hostlen);
2042
2043       strcat(keyserver->host,srvlist[i].target);
2044
2045       if(srvlist[i].port!=389)
2046         {
2047           char port[7];
2048
2049           hostlen+=6; /* a colon, plus 5 digits (unsigned 16-bit value) */
2050           keyserver->host=xrealloc(keyserver->host,hostlen);
2051
2052           snprintf(port,7,":%u",srvlist[i].port);
2053           strcat(keyserver->host,port);
2054         }
2055
2056       strcat(keyserver->host," ");
2057     }
2058
2059   free(srvlist);
2060 #endif
2061
2062   /* If all else fails, do the PGP Universal trick of
2063      ldap://keys.(domain) */
2064
2065   hostlen+=5+strlen(domain);
2066   keyserver->host=xrealloc(keyserver->host,hostlen);
2067   strcat(keyserver->host,"keys.");
2068   strcat(keyserver->host,domain);
2069
2070   append_to_strlist(&list,name);
2071
2072   rc = gpg_error (GPG_ERR_NOT_IMPLEMENTED); /*FIXME*/
2073        /* keyserver_work (ctrl, KS_GETNAME, list, NULL, */
2074        /*                 0, fpr, fpr_len, keyserver); */
2075
2076   free_strlist(list);
2077
2078   free_keyserver_spec(keyserver);
2079
2080   return rc;
2081 #endif
2082 }