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