Keyserver search and get basically works again.
[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 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /* !!! FIXME: Replace all printf by es_printf.  FIXME !!! */
22
23
24 #include <config.h>
25 #include <ctype.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <stdlib.h>
29 #include <assert.h>
30 #include <errno.h>
31
32 #include "gpg.h"
33 #include "iobuf.h"
34 #include "filter.h"
35 #include "keydb.h"
36 #include "status.h"
37 #include "exec.h"
38 #include "main.h"
39 #include "i18n.h"
40 #include "ttyio.h"
41 #include "options.h"
42 #include "packet.h"
43 #include "trustdb.h"
44 #include "keyserver-internal.h"
45 #include "util.h"
46 #include "dns-cert.h"
47 #include "pka.h"
48 #ifdef USE_DNS_SRV
49 #include "srv.h"
50 #endif
51 #include "membuf.h"
52 #include "call-dirmngr.h"
53
54 #ifdef HAVE_W32_SYSTEM
55 /* It seems Vista doesn't grok X_OK and so fails access() tests.
56    Previous versions interpreted X_OK as F_OK anyway, so we'll just
57    use F_OK directly. */
58 #undef X_OK
59 #define X_OK F_OK
60 #endif /* HAVE_W32_SYSTEM */
61
62 struct keyrec
63 {
64   KEYDB_SEARCH_DESC desc;
65   u32 createtime,expiretime;
66   int size,flags;
67   byte type;
68   IOBUF uidbuf;
69   unsigned int lines;
70 };
71
72 /* Parameters for the search line handler.  */
73 struct search_line_handler_parm_s
74 {
75   ctrl_t ctrl;     /* The session control structure.  */
76   char *searchstr_disp;  /* Native encoded search string or NULL.  */
77   KEYDB_SEARCH_DESC *desc; /* Array with search descriptions.  */
78   int count;      /* Number of keys we are currently prepared to
79                      handle.  This is the size of the DESC array.  If
80                      it is too small, it will grow safely.  */
81   int validcount; /* Enable the "Key x-y of z" messages. */
82   int nkeys;      /* Number of processed records.  */
83   int any_lines;  /* At least one line has been processed.  */
84   unsigned int numlines;  /* Counter for displayed lines.  */
85   int eof_seen;   /* EOF encountered.  */
86   int not_found;  /* Set if no keys have been found.  */
87 };
88
89
90 enum ks_action {KS_UNKNOWN=0,KS_GET,KS_GETNAME,KS_SEND,KS_SEARCH};
91
92 static struct parse_options keyserver_opts[]=
93   {
94     /* some of these options are not real - just for the help
95        message */
96     {"max-cert-size",0,NULL,NULL},
97     {"include-revoked",0,NULL,N_("include revoked keys in search results")},
98     {"include-subkeys",0,NULL,N_("include subkeys when searching by key ID")},
99     {"use-temp-files",0,NULL,
100      N_("use temporary files to pass data to keyserver helpers")},
101     {"keep-temp-files",KEYSERVER_KEEP_TEMP_FILES,NULL,
102      N_("do not delete temporary files after using them")},
103     {"refresh-add-fake-v3-keyids",KEYSERVER_ADD_FAKE_V3,NULL,
104      NULL},
105     {"auto-key-retrieve",KEYSERVER_AUTO_KEY_RETRIEVE,NULL,
106      N_("automatically retrieve keys when verifying signatures")},
107     {"honor-keyserver-url",KEYSERVER_HONOR_KEYSERVER_URL,NULL,
108      N_("honor the preferred keyserver URL set on the key")},
109     {"honor-pka-record",KEYSERVER_HONOR_PKA_RECORD,NULL,
110      N_("honor the PKA record set on a key when retrieving keys")},
111     {NULL,0,NULL,NULL}
112   };
113
114 static int keyserver_work (ctrl_t ctrl, enum ks_action action,strlist_t list,
115                            KEYDB_SEARCH_DESC *desc,int count,
116                            unsigned char **fpr,size_t *fpr_len,
117                            struct keyserver_spec *keyserver);
118 static gpg_error_t keyserver_get (ctrl_t ctrl,
119                                   KEYDB_SEARCH_DESC *desc, int ndesc,
120                                   struct keyserver_spec *keyserver);
121
122
123 /* Reasonable guess */
124 #define DEFAULT_MAX_CERT_SIZE 16384
125
126 static size_t max_cert_size=DEFAULT_MAX_CERT_SIZE;
127
128 static void
129 add_canonical_option(char *option,strlist_t *list)
130 {
131   char *arg=argsplit(option);
132
133   if(arg)
134     {
135       char *joined;
136
137       joined=xmalloc(strlen(option)+1+strlen(arg)+1);
138       /* Make a canonical name=value form with no spaces */
139       strcpy(joined,option);
140       strcat(joined,"=");
141       strcat(joined,arg);
142       append_to_strlist(list,joined);
143       xfree(joined);
144     }
145   else
146     append_to_strlist(list,option);
147 }
148
149 int
150 parse_keyserver_options(char *options)
151 {
152   int ret=1;
153   char *tok;
154   char *max_cert=NULL;
155
156   keyserver_opts[0].value=&max_cert;
157
158   while((tok=optsep(&options)))
159     {
160       if(tok[0]=='\0')
161         continue;
162
163       /* For backwards compatibility.  1.2.x used honor-http-proxy and
164          there are a good number of documents published that recommend
165          it. */
166       if(ascii_strcasecmp(tok,"honor-http-proxy")==0)
167         tok="http-proxy";
168       else if(ascii_strcasecmp(tok,"no-honor-http-proxy")==0)
169         tok="no-http-proxy";
170
171       /* We accept quite a few possible options here - some options to
172          handle specially, the keyserver_options list, and import and
173          export options that pertain to keyserver operations.  Note
174          that you must use strncasecmp here as there might be an
175          =argument attached which will foil the use of strcasecmp. */
176
177 #ifdef EXEC_TEMPFILE_ONLY
178       if(ascii_strncasecmp(tok,"use-temp-files",14)==0 ||
179               ascii_strncasecmp(tok,"no-use-temp-files",17)==0)
180         log_info(_("WARNING: keyserver option `%s' is not used"
181                    " on this platform\n"),tok);
182 #else
183       if(ascii_strncasecmp(tok,"use-temp-files",14)==0)
184         opt.keyserver_options.options|=KEYSERVER_USE_TEMP_FILES;
185       else if(ascii_strncasecmp(tok,"no-use-temp-files",17)==0)
186         opt.keyserver_options.options&=~KEYSERVER_USE_TEMP_FILES;
187 #endif
188       else if(!parse_options(tok,&opt.keyserver_options.options,
189                              keyserver_opts,0)
190          && !parse_import_options(tok,
191                                   &opt.keyserver_options.import_options,0)
192          && !parse_export_options(tok,
193                                   &opt.keyserver_options.export_options,0))
194         {
195           /* All of the standard options have failed, so the option is
196              destined for a keyserver plugin. */
197           add_canonical_option(tok,&opt.keyserver_options.other);
198         }
199     }
200
201   if(max_cert)
202     {
203       max_cert_size=strtoul(max_cert,(char **)NULL,10);
204
205       if(max_cert_size==0)
206         max_cert_size=DEFAULT_MAX_CERT_SIZE;
207     }
208
209   return ret;
210 }
211
212 void
213 free_keyserver_spec(struct keyserver_spec *keyserver)
214 {
215   xfree(keyserver->uri);
216   xfree(keyserver->scheme);
217   xfree(keyserver->auth);
218   xfree(keyserver->host);
219   xfree(keyserver->port);
220   xfree(keyserver->path);
221   xfree(keyserver->opaque);
222   free_strlist(keyserver->options);
223   xfree(keyserver);
224 }
225
226 /* Return 0 for match */
227 static int
228 cmp_keyserver_spec(struct keyserver_spec *one,struct keyserver_spec *two)
229 {
230   if(ascii_strcasecmp(one->scheme,two->scheme)==0)
231     {
232       if(one->host && two->host && ascii_strcasecmp(one->host,two->host)==0)
233         {
234           if((one->port && two->port
235               && ascii_strcasecmp(one->port,two->port)==0)
236              || (!one->port && !two->port))
237             return 0;
238         }
239       else if(one->opaque && two->opaque
240               && ascii_strcasecmp(one->opaque,two->opaque)==0)
241         return 0;
242     }
243
244   return 1;
245 }
246
247 /* Try and match one of our keyservers.  If we can, return that.  If
248    we can't, return our input. */
249 struct keyserver_spec *
250 keyserver_match(struct keyserver_spec *spec)
251 {
252   struct keyserver_spec *ks;
253
254   for(ks=opt.keyserver;ks;ks=ks->next)
255     if(cmp_keyserver_spec(spec,ks)==0)
256       return ks;
257
258   return spec;
259 }
260
261 /* TODO: once we cut over to an all-curl world, we don't need this
262    parser any longer so it can be removed, or at least moved to
263    keyserver/ksutil.c for limited use in gpgkeys_ldap or the like. */
264
265 keyserver_spec_t
266 parse_keyserver_uri (const char *string,int require_scheme,
267                      const char *configname,unsigned int configlineno)
268 {
269   int assume_hkp=0;
270   struct keyserver_spec *keyserver;
271   const char *idx;
272   int count;
273   char *uri,*options;
274
275   assert(string!=NULL);
276
277   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
278
279   uri=xstrdup(string);
280
281   options=strchr(uri,' ');
282   if(options)
283     {
284       char *tok;
285
286       *options='\0';
287       options++;
288
289       while((tok=optsep(&options)))
290         add_canonical_option(tok,&keyserver->options);
291     }
292
293   /* Get the scheme */
294
295   for(idx=uri,count=0;*idx && *idx!=':';idx++)
296     {
297       count++;
298
299       /* Do we see the start of an RFC-2732 ipv6 address here?  If so,
300          there clearly isn't a scheme so get out early. */
301       if(*idx=='[')
302         {
303           /* Was the '[' the first thing in the string?  If not, we
304              have a mangled scheme with a [ in it so fail. */
305           if(count==1)
306             break;
307           else
308             goto fail;
309         }
310     }
311
312   if(count==0)
313     goto fail;
314
315   if(*idx=='\0' || *idx=='[')
316     {
317       if(require_scheme)
318         return NULL;
319
320       /* Assume HKP if there is no scheme */
321       assume_hkp=1;
322       keyserver->scheme=xstrdup("hkp");
323
324       keyserver->uri=xmalloc(strlen(keyserver->scheme)+3+strlen(uri)+1);
325       strcpy(keyserver->uri,keyserver->scheme);
326       strcat(keyserver->uri,"://");
327       strcat(keyserver->uri,uri);
328     }
329   else
330     {
331       int i;
332
333       keyserver->uri=xstrdup(uri);
334
335       keyserver->scheme=xmalloc(count+1);
336
337       /* Force to lowercase */
338       for(i=0;i<count;i++)
339         keyserver->scheme[i]=ascii_tolower(uri[i]);
340
341       keyserver->scheme[i]='\0';
342
343       /* Skip past the scheme and colon */
344       uri+=count+1;
345     }
346
347   if(ascii_strcasecmp(keyserver->scheme,"x-broken-hkp")==0)
348     {
349       deprecated_warning(configname,configlineno,"x-broken-hkp",
350                          "--keyserver-options ","broken-http-proxy");
351       xfree(keyserver->scheme);
352       keyserver->scheme=xstrdup("hkp");
353       append_to_strlist(&opt.keyserver_options.other,"broken-http-proxy");
354     }
355   else if(ascii_strcasecmp(keyserver->scheme,"x-hkp")==0)
356     {
357       /* Canonicalize this to "hkp" so it works with both the internal
358          and external keyserver interface. */
359       xfree(keyserver->scheme);
360       keyserver->scheme=xstrdup("hkp");
361     }
362
363   if (uri[0]=='/' && uri[1]=='/' && uri[2] == '/')
364     {
365       /* Three slashes means network path with a default host name.
366          This is a hack because it does not crok all possible
367          combiantions.  We should better repalce all code bythe parser
368          from http.c.  */
369       keyserver->path = xstrdup (uri+2);
370     }
371   else if(assume_hkp || (uri[0]=='/' && uri[1]=='/'))
372     {
373       /* Two slashes means network path. */
374
375       /* Skip over the "//", if any */
376       if(!assume_hkp)
377         uri+=2;
378
379       /* Do we have userinfo auth data present? */
380       for(idx=uri,count=0;*idx && *idx!='@' && *idx!='/';idx++)
381         count++;
382
383       /* We found a @ before the slash, so that means everything
384          before the @ is auth data. */
385       if(*idx=='@')
386         {
387           if(count==0)
388             goto fail;
389
390           keyserver->auth=xmalloc(count+1);
391           strncpy(keyserver->auth,uri,count);
392           keyserver->auth[count]='\0';
393           uri+=count+1;
394         }
395
396       /* Is it an RFC-2732 ipv6 [literal address] ? */
397       if(*uri=='[')
398         {
399           for(idx=uri+1,count=1;*idx
400                 && ((isascii (*idx) && isxdigit(*idx))
401                     || *idx==':' || *idx=='.');idx++)
402             count++;
403
404           /* Is the ipv6 literal address terminated? */
405           if(*idx==']')
406             count++;
407           else
408             goto fail;
409         }
410       else
411         for(idx=uri,count=0;*idx && *idx!=':' && *idx!='/';idx++)
412           count++;
413
414       if(count==0)
415         goto fail;
416
417       keyserver->host=xmalloc(count+1);
418       strncpy(keyserver->host,uri,count);
419       keyserver->host[count]='\0';
420
421       /* Skip past the host */
422       uri+=count;
423
424       if(*uri==':')
425         {
426           /* It would seem to be reasonable to limit the range of the
427              ports to values between 1-65535, but RFC 1738 and 1808
428              imply there is no limit.  Of course, the real world has
429              limits. */
430
431           for(idx=uri+1,count=0;*idx && *idx!='/';idx++)
432             {
433               count++;
434
435               /* Ports are digits only */
436               if(!digitp(idx))
437                 goto fail;
438             }
439
440           keyserver->port=xmalloc(count+1);
441           strncpy(keyserver->port,uri+1,count);
442           keyserver->port[count]='\0';
443
444           /* Skip past the colon and port number */
445           uri+=1+count;
446         }
447
448       /* Everything else is the path */
449       if(*uri)
450         keyserver->path=xstrdup(uri);
451       else
452         keyserver->path=xstrdup("/");
453
454       if(keyserver->path[1])
455         keyserver->flags.direct_uri=1;
456     }
457   else if(uri[0]!='/')
458     {
459       /* No slash means opaque.  Just record the opaque blob and get
460          out. */
461       keyserver->opaque=xstrdup(uri);
462     }
463   else
464     {
465       /* One slash means absolute path.  We don't need to support that
466          yet. */
467       goto fail;
468     }
469
470   return keyserver;
471
472  fail:
473   free_keyserver_spec(keyserver);
474
475   return NULL;
476 }
477
478 struct keyserver_spec *
479 parse_preferred_keyserver(PKT_signature *sig)
480 {
481   struct keyserver_spec *spec=NULL;
482   const byte *p;
483   size_t plen;
484
485   p=parse_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&plen);
486   if(p && plen)
487     {
488       byte *dupe=xmalloc(plen+1);
489
490       memcpy(dupe,p,plen);
491       dupe[plen]='\0';
492       spec=parse_keyserver_uri(dupe,1,NULL,0);
493       xfree(dupe);
494     }
495
496   return spec;
497 }
498
499 static void
500 print_keyrec(int number,struct keyrec *keyrec)
501 {
502   int i;
503
504   iobuf_writebyte(keyrec->uidbuf,0);
505   iobuf_flush_temp(keyrec->uidbuf);
506   printf("(%d)\t%s  ",number,iobuf_get_temp_buffer(keyrec->uidbuf));
507
508   if(keyrec->size>0)
509     printf("%d bit ",keyrec->size);
510
511   if(keyrec->type)
512     {
513       const char *str = gcry_pk_algo_name (keyrec->type);
514
515       if(str)
516         printf("%s ",str);
517       else
518         printf("unknown ");
519     }
520
521   switch(keyrec->desc.mode)
522     {
523       /* If the keyserver helper gave us a short keyid, we have no
524          choice but to use it.  Do check --keyid-format to add a 0x if
525          needed. */
526     case KEYDB_SEARCH_MODE_SHORT_KID:
527       printf("key %s%08lX",
528              (opt.keyid_format==KF_0xSHORT
529               || opt.keyid_format==KF_0xLONG)?"0x":"",
530              (ulong)keyrec->desc.u.kid[1]);
531       break;
532
533       /* However, if it gave us a long keyid, we can honor
534          --keyid-format */
535     case KEYDB_SEARCH_MODE_LONG_KID:
536       printf("key %s",keystr(keyrec->desc.u.kid));
537       break;
538
539     case KEYDB_SEARCH_MODE_FPR16:
540       printf("key ");
541       for(i=0;i<16;i++)
542         printf("%02X",keyrec->desc.u.fpr[i]);
543       break;
544
545     case KEYDB_SEARCH_MODE_FPR20:
546       printf("key ");
547       for(i=0;i<20;i++)
548         printf("%02X",keyrec->desc.u.fpr[i]);
549       break;
550
551     default:
552       BUG();
553       break;
554     }
555
556   if(keyrec->createtime>0)
557     {
558       printf(", ");
559       printf(_("created: %s"),strtimestamp(keyrec->createtime));
560     }
561
562   if(keyrec->expiretime>0)
563     {
564       printf(", ");
565       printf(_("expires: %s"),strtimestamp(keyrec->expiretime));
566     }
567
568   if(keyrec->flags&1)
569     printf(" (%s)",_("revoked"));
570   if(keyrec->flags&2)
571     printf(" (%s)",_("disabled"));
572   if(keyrec->flags&4)
573     printf(" (%s)",_("expired"));
574
575   printf("\n");
576 }
577
578 /* Returns a keyrec (which must be freed) once a key is complete, and
579    NULL otherwise.  Call with a NULL keystring once key parsing is
580    complete to return any unfinished keys. */
581 static struct keyrec *
582 parse_keyrec(char *keystring)
583 {
584   /* FIXME: Remove the static and put the data into the parms we use
585      for the caller anyway.  */
586   static struct keyrec *work=NULL;
587   struct keyrec *ret=NULL;
588   char *record;
589   int i;
590
591   if(keystring==NULL)
592     {
593       if(work==NULL)
594         return NULL;
595       else if(work->desc.mode==KEYDB_SEARCH_MODE_NONE)
596         {
597           xfree(work);
598           return NULL;
599         }
600       else
601         {
602           ret=work;
603           work=NULL;
604           return ret;
605         }
606     }
607
608   if(work==NULL)
609     {
610       work=xmalloc_clear(sizeof(struct keyrec));
611       work->uidbuf=iobuf_temp();
612     }
613
614   trim_trailing_ws (keystring, strlen (keystring));
615
616   if((record=strsep(&keystring,":"))==NULL)
617     return ret;
618
619   if(ascii_strcasecmp("pub",record)==0)
620     {
621       char *tok;
622       gpg_error_t err;
623
624       if(work->desc.mode)
625         {
626           ret=work;
627           work=xmalloc_clear(sizeof(struct keyrec));
628           work->uidbuf=iobuf_temp();
629         }
630
631       if((tok=strsep(&keystring,":"))==NULL)
632         return ret;
633
634       err = classify_user_id (tok, &work->desc);
635       if (err || (work->desc.mode    != KEYDB_SEARCH_MODE_SHORT_KID
636                   && work->desc.mode != KEYDB_SEARCH_MODE_LONG_KID
637                   && work->desc.mode != KEYDB_SEARCH_MODE_FPR16
638                   && work->desc.mode != KEYDB_SEARCH_MODE_FPR20))
639         {
640           work->desc.mode=KEYDB_SEARCH_MODE_NONE;
641           return ret;
642         }
643
644       /* Note all items after this are optional.  This allows us to
645          have a pub line as simple as pub:keyid and nothing else. */
646
647       work->lines++;
648
649       if((tok=strsep(&keystring,":"))==NULL)
650         return ret;
651
652       work->type=atoi(tok);
653
654       if((tok=strsep(&keystring,":"))==NULL)
655         return ret;
656
657       work->size=atoi(tok);
658
659       if((tok=strsep(&keystring,":"))==NULL)
660         return ret;
661
662       if(atoi(tok)<=0)
663         work->createtime=0;
664       else
665         work->createtime=atoi(tok);
666
667       if((tok=strsep(&keystring,":"))==NULL)
668         return ret;
669
670       if(atoi(tok)<=0)
671         work->expiretime=0;
672       else
673         {
674           work->expiretime=atoi(tok);
675           /* Force the 'e' flag on if this key is expired. */
676           if(work->expiretime<=make_timestamp())
677             work->flags|=4;
678         }
679
680       if((tok=strsep(&keystring,":"))==NULL)
681         return ret;
682
683       while(*tok)
684         switch(*tok++)
685           {
686           case 'r':
687           case 'R':
688             work->flags|=1;
689             break;
690
691           case 'd':
692           case 'D':
693             work->flags|=2;
694             break;
695
696           case 'e':
697           case 'E':
698             work->flags|=4;
699             break;
700           }
701     }
702   else if(ascii_strcasecmp("uid",record)==0 && work->desc.mode)
703     {
704       char *userid,*tok,*decoded;
705
706       if((tok=strsep(&keystring,":"))==NULL)
707         return ret;
708
709       if(strlen(tok)==0)
710         return ret;
711
712       userid=tok;
713
714       /* By definition, de-%-encoding is always smaller than the
715          original string so we can decode in place. */
716
717       i=0;
718
719       while(*tok)
720         if(tok[0]=='%' && tok[1] && tok[2])
721           {
722             int c;
723
724             userid[i] = (c=hextobyte(&tok[1])) == -1 ? '?' : c;
725             i++;
726             tok+=3;
727           }
728         else
729           userid[i++]=*tok++;
730
731       /* We don't care about the other info provided in the uid: line
732          since no keyserver supports marking userids with timestamps
733          or revoked/expired/disabled yet. */
734
735       /* No need to check for control characters, as utf8_to_native
736          does this for us. */
737
738       decoded=utf8_to_native(userid,i,0);
739       if(strlen(decoded)>opt.screen_columns-10)
740         decoded[opt.screen_columns-10]='\0';
741       iobuf_writestr(work->uidbuf,decoded);
742       xfree(decoded);
743       iobuf_writestr(work->uidbuf,"\n\t");
744       work->lines++;
745     }
746
747   /* Ignore any records other than "pri" and "uid" for easy future
748      growth. */
749
750   return ret;
751 }
752
753 /* Show a prompt and allow the user to select keys for retrieval.  */
754 static gpg_error_t
755 show_prompt (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int numdesc,
756              int count, const char *search)
757 {
758   gpg_error_t err;
759   char *answer = NULL;
760
761   fflush (stdout);
762
763   if (count && opt.command_fd == -1)
764     {
765       static int from = 1;
766       tty_printf ("Keys %d-%d of %d for \"%s\".  ",
767                   from, numdesc, count, search);
768       from = numdesc + 1;
769     }
770
771  again:
772   err = 0;
773   xfree (answer);
774   answer = cpr_get_no_help ("keysearch.prompt",
775                             _("Enter number(s), N)ext, or Q)uit > "));
776   /* control-d */
777   if (answer[0]=='\x04')
778     {
779       tty_printf ("Q\n");
780       answer[0] = 'q';
781     }
782
783   if (answer[0]=='q' || answer[0]=='Q')
784     err = gpg_error (GPG_ERR_CANCELED);
785   else if (atoi (answer) >= 1 && atoi (answer) <= numdesc)
786     {
787       char *split = answer;
788       char *num;
789       int numarray[50];
790       int numidx = 0;
791       int idx;
792
793       while ((num = strsep (&split, " ,")))
794         if (atoi (num) >= 1 && atoi (num) <= numdesc)
795           {
796             if (numidx >= DIM (numarray))
797               {
798                 tty_printf ("Too many keys selected\n");
799                 goto again;
800               }
801             numarray[numidx++] = atoi (num);
802           }
803
804       if (!numidx)
805         goto again;
806
807       {
808         KEYDB_SEARCH_DESC *selarray;
809
810         selarray = xtrymalloc (numidx * sizeof *selarray);
811         if (!selarray)
812           {
813             err = gpg_error_from_syserror ();
814             goto leave;
815           }
816         for (idx = 0; idx < numidx; idx++)
817           selarray[idx] = desc[numarray[idx]-1];
818         err = keyserver_get (ctrl, selarray, numidx, NULL);
819         xfree (selarray);
820       }
821     }
822
823  leave:
824   xfree (answer);
825   return err;
826 }
827
828
829 /* This is a callback used by call-dirmngr.c to process the result of
830    KS_SEARCH command.  LINE is the actual data line received with all
831    escaping removed and guaranteed to be exactly one line with
832    stripped LF; an EOF is indicated by LINE passed as NULL.  LINE may
833    be modified after return.  */
834 static gpg_error_t
835 search_line_handler (void *opaque, char *line)
836 {
837   struct search_line_handler_parm_s *parm = opaque;
838   gpg_error_t err = 0;
839   struct keyrec *keyrec;
840
841   if (parm->eof_seen && line)
842     {
843       log_debug ("ooops: unexpected data after EOF\n");
844       line = NULL;
845     }
846
847   /* Print the received line.  */
848   if (opt.with_colons && line)
849     {
850       log_debug ("%s\n",line);
851     }
852
853   /* Look for an info: line.  The only current info: values defined
854      are the version and key count. */
855   if (line && !parm->any_lines && !ascii_strncasecmp ("info:", line, 5))
856     {
857       char *str = line + 5;
858       char *tok;
859
860       if ((tok = strsep (&str, ":")))
861         {
862           int version;
863
864           if (sscanf (tok, "%d", &version) !=1 )
865             version = 1;
866
867           if (version !=1 )
868             {
869               log_error (_("invalid keyserver protocol "
870                            "(us %d!=handler %d)\n"), 1, version);
871               return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
872             }
873         }
874
875       if ((tok = strsep (&str, ":"))
876           && sscanf (tok, "%d", &parm->count) == 1)
877         {
878           if (!parm->count)
879             parm->not_found = 1;/* Server indicated that no items follow.  */
880           else if (parm->count < 0)
881             parm->count = 10;   /* Bad value - assume something reasonable.  */
882           else
883             parm->validcount = 1; /* COUNT seems to be okay.  */
884         }
885
886       parm->any_lines = 1;
887       return 0; /* Line processing finished.  */
888     }
889
890  again:
891   if (line)
892     keyrec = parse_keyrec (line);
893   else
894     {
895       /* Received EOF - flush data */
896       parm->eof_seen = 1;
897       keyrec = parse_keyrec (NULL);
898       if (!keyrec)
899         {
900           if (!parm->nkeys)
901             parm->not_found = 1;  /* No keys at all.  */
902           else
903             {
904               if (parm->nkeys != parm->count)
905                 parm->validcount = 0;
906
907               if (!(opt.with_colons && opt.batch))
908                 {
909                   err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
910                                      parm->validcount? parm->count : 0,
911                                      parm->searchstr_disp);
912                   return err;
913                 }
914             }
915         }
916     }
917
918   /* Save the key in the key array.  */
919   if (keyrec)
920     {
921       /* Allocate or enlarge the key array if needed.  */
922       if (!parm->desc)
923         {
924           if (parm->count < 1)
925             {
926               parm->count = 10;
927               parm->validcount = 0;
928             }
929           parm->desc = xtrymalloc (parm->count * sizeof *parm->desc);
930           if (!parm->desc)
931             {
932               err = gpg_error_from_syserror ();
933               iobuf_close (keyrec->uidbuf);
934               xfree (keyrec);
935               return err;
936             }
937         }
938       else if (parm->nkeys == parm->count)
939         {
940           /* Keyserver sent more keys than claimed in the info: line. */
941           KEYDB_SEARCH_DESC *tmp;
942           int newcount = parm->count + 10;
943
944           tmp = xtryrealloc (parm->desc, newcount * sizeof *parm->desc);
945           if (!tmp)
946             {
947               err = gpg_error_from_syserror ();
948               iobuf_close (keyrec->uidbuf);
949               xfree (keyrec);
950               return err;
951             }
952           parm->count = newcount;
953           parm->desc = tmp;
954           parm->validcount = 0;
955         }
956
957       parm->desc[parm->nkeys] = keyrec->desc;
958
959       if (!opt.with_colons)
960         {
961           /* SCREEN_LINES - 1 for the prompt. */
962           if (parm->numlines + keyrec->lines > opt.screen_lines - 1)
963             {
964               err = show_prompt (parm->ctrl, parm->desc, parm->nkeys,
965                                  parm->validcount ? parm->count:0,
966                                  parm->searchstr_disp);
967               if (err)
968                 return err;
969               parm->numlines = 0;
970             }
971
972           print_keyrec (parm->nkeys+1, keyrec);
973         }
974
975       parm->numlines += keyrec->lines;
976       iobuf_close (keyrec->uidbuf);
977       xfree (keyrec);
978
979       parm->any_lines = 1;
980       parm->nkeys++;
981
982       /* If we are here due to a flush after the EOF, run again for
983          the last prompt.  Fixme: Make this code better readable. */
984       if (parm->eof_seen)
985         goto again;
986     }
987
988   return 0;
989 }
990
991
992 /* We sometimes want to use a different gpgkeys_xxx for a given
993    protocol (for example, ldaps is handled by gpgkeys_ldap).  Map
994    these here. */
995 static const char *
996 keyserver_typemap(const char *type)
997 {
998   if(strcmp(type,"ldaps")==0)
999     return "ldap";
1000   else if(strcmp(type,"hkps")==0)
1001     return "hkp";
1002   else
1003     return type;
1004 }
1005
1006 /* The PGP LDAP and the curl fetch-a-LDAP-object methodologies are
1007    sufficiently different that we can't use curl to do LDAP. */
1008 static int
1009 direct_uri_map(const char *scheme,unsigned int is_direct)
1010 {
1011   if(is_direct && strcmp(scheme,"ldap")==0)
1012     return 1;
1013
1014   return 0;
1015 }
1016
1017 #if GNUPG_MAJOR_VERSION == 2
1018 #define GPGKEYS_PREFIX "gpg2keys_"
1019 #else
1020 #define GPGKEYS_PREFIX "gpgkeys_"
1021 #endif
1022 #define GPGKEYS_CURL GPGKEYS_PREFIX "curl" EXEEXT
1023 #define GPGKEYS_PREFIX_LEN (strlen(GPGKEYS_CURL))
1024 #define KEYSERVER_ARGS_KEEP " -o \"%O\" \"%I\""
1025 #define KEYSERVER_ARGS_NOKEEP " -o \"%o\" \"%i\""
1026
1027 static int
1028 keyserver_spawn (ctrl_t ctrl,
1029                  enum ks_action action,strlist_t list,KEYDB_SEARCH_DESC *desc,
1030                  int count,int *prog,unsigned char **fpr,size_t *fpr_len,
1031                  struct keyserver_spec *keyserver)
1032 {
1033   int ret=0,i,gotversion=0,outofband=0;
1034   strlist_t temp;
1035   unsigned int maxlen,buflen;
1036   char *command,*end,*searchstr=NULL;
1037   byte *line=NULL;
1038   struct exec_info *spawn;
1039   const char *scheme;
1040   const char *libexecdir = gnupg_libexecdir ();
1041
1042   assert(keyserver);
1043
1044 #ifdef EXEC_TEMPFILE_ONLY
1045   opt.keyserver_options.options|=KEYSERVER_USE_TEMP_FILES;
1046 #endif
1047
1048   /* Build the filename for the helper to execute */
1049   scheme=keyserver_typemap(keyserver->scheme);
1050
1051 #ifdef DISABLE_KEYSERVER_PATH
1052   /* Destroy any path we might have.  This is a little tricky,
1053      portability-wise.  It's not correct to delete the PATH
1054      environment variable, as that may fall back to a system built-in
1055      PATH.  Similarly, it is not correct to set PATH to the null
1056      string (PATH="") since this actually deletes the PATH environment
1057      variable under MinGW.  The safest thing to do here is to force
1058      PATH to be GNUPG_LIBEXECDIR.  All this is not that meaningful on
1059      Unix-like systems (since we're going to give a full path to
1060      gpgkeys_foo), but on W32 it prevents loading any DLLs from
1061      directories in %PATH%.
1062
1063      After some more thinking about this we came to the conclusion
1064      that it is better to load the helpers from the directory where
1065      the program of this process lives.  Fortunately Windows provides
1066      a way to retrieve this and our gnupg_libexecdir function has been
1067      modified to return just this.  Setting the exec-path is not
1068      anymore required.
1069        set_exec_path(libexecdir);
1070  */
1071 #else
1072   if(opt.exec_path_set)
1073     {
1074       /* If exec-path was set, and DISABLE_KEYSERVER_PATH is
1075          undefined, then don't specify a full path to gpgkeys_foo, so
1076          that the PATH can work. */
1077       command=xmalloc(GPGKEYS_PREFIX_LEN+strlen(scheme)+3+strlen(EXEEXT)+1);
1078       command[0]='\0';
1079     }
1080   else
1081 #endif
1082     {
1083       /* Specify a full path to gpgkeys_foo. */
1084       command=xmalloc(strlen(libexecdir)+strlen(DIRSEP_S)+
1085                       GPGKEYS_PREFIX_LEN+strlen(scheme)+3+strlen(EXEEXT)+1);
1086       strcpy(command,libexecdir);
1087       strcat(command,DIRSEP_S);
1088     }
1089
1090   end=command+strlen(command);
1091
1092   /* Build a path for the keyserver helper.  If it is direct_uri
1093      (i.e. an object fetch and not a keyserver), then add "_uri" to
1094      the end to distinguish the keyserver helper from an object
1095      fetcher that can speak that protocol (this is a problem for
1096      LDAP). */
1097
1098   strcat(command,GPGKEYS_PREFIX);
1099   strcat(command,scheme);
1100
1101   /* This "_uri" thing is in case we need to call a direct handler
1102      instead of the keyserver handler.  This lets us use gpgkeys_curl
1103      or gpgkeys_ldap_uri (we don't provide it, but a user might)
1104      instead of gpgkeys_ldap to fetch things like
1105      ldap://keyserver.pgp.com/o=PGP%20keys?pgpkey?sub?pgpkeyid=99242560 */
1106
1107   if(direct_uri_map(scheme,keyserver->flags.direct_uri))
1108     strcat(command,"_uri");
1109
1110   strcat(command,EXEEXT);
1111
1112   /* Can we execute it?  If not, try curl as our catchall. */
1113   if(path_access(command,X_OK)!=0)
1114     strcpy(end,GPGKEYS_CURL);
1115
1116   if(opt.keyserver_options.options&KEYSERVER_USE_TEMP_FILES)
1117     {
1118       if(opt.keyserver_options.options&KEYSERVER_KEEP_TEMP_FILES)
1119         {
1120           command=xrealloc(command,strlen(command)+
1121                             strlen(KEYSERVER_ARGS_KEEP)+1);
1122           strcat(command,KEYSERVER_ARGS_KEEP);
1123         }
1124       else
1125         {
1126           command=xrealloc(command,strlen(command)+
1127                             strlen(KEYSERVER_ARGS_NOKEEP)+1);
1128           strcat(command,KEYSERVER_ARGS_NOKEEP);
1129         }
1130
1131       ret=exec_write(&spawn,NULL,command,NULL,0,0);
1132     }
1133   else
1134     ret=exec_write(&spawn,command,NULL,NULL,0,0);
1135
1136   xfree(command);
1137
1138   if(ret)
1139     return ret;
1140
1141   fprintf(spawn->tochild,
1142           "# This is a GnuPG %s keyserver communications file\n",VERSION);
1143   fprintf(spawn->tochild,"VERSION %d\n",KEYSERVER_PROTO_VERSION);
1144   fprintf(spawn->tochild,"PROGRAM %s\n",VERSION);
1145   fprintf(spawn->tochild,"SCHEME %s\n",keyserver->scheme);
1146
1147   if(keyserver->opaque)
1148     fprintf(spawn->tochild,"OPAQUE %s\n",keyserver->opaque);
1149   else
1150     {
1151       if(keyserver->auth)
1152         fprintf(spawn->tochild,"AUTH %s\n",keyserver->auth);
1153
1154       if(keyserver->host)
1155         fprintf(spawn->tochild,"HOST %s\n",keyserver->host);
1156
1157       if(keyserver->port)
1158         fprintf(spawn->tochild,"PORT %s\n",keyserver->port);
1159
1160       if(keyserver->path)
1161         fprintf(spawn->tochild,"PATH %s\n",keyserver->path);
1162     }
1163
1164   /* Write global options */
1165
1166   for(temp=opt.keyserver_options.other;temp;temp=temp->next)
1167     fprintf(spawn->tochild,"OPTION %s\n",temp->d);
1168
1169   /* Write per-keyserver options */
1170
1171   for(temp=keyserver->options;temp;temp=temp->next)
1172     fprintf(spawn->tochild,"OPTION %s\n",temp->d);
1173
1174   switch(action)
1175     {
1176     case KS_GET:
1177       {
1178         fprintf(spawn->tochild,"COMMAND GET\n\n");
1179
1180         /* Which keys do we want? */
1181
1182         for(i=0;i<count;i++)
1183           {
1184             int quiet=0;
1185
1186             if(desc[i].mode==KEYDB_SEARCH_MODE_FPR20)
1187               {
1188                 int f;
1189
1190                 fprintf(spawn->tochild,"0x");
1191
1192                 for(f=0;f<MAX_FINGERPRINT_LEN;f++)
1193                   fprintf(spawn->tochild,"%02X",desc[i].u.fpr[f]);
1194
1195                 fprintf(spawn->tochild,"\n");
1196               }
1197             else if(desc[i].mode==KEYDB_SEARCH_MODE_FPR16)
1198               {
1199                 int f;
1200
1201                 fprintf(spawn->tochild,"0x");
1202
1203                 for(f=0;f<16;f++)
1204                   fprintf(spawn->tochild,"%02X",desc[i].u.fpr[f]);
1205
1206                 fprintf(spawn->tochild,"\n");
1207               }
1208             else if(desc[i].mode==KEYDB_SEARCH_MODE_LONG_KID)
1209               fprintf(spawn->tochild,"0x%08lX%08lX\n",
1210                       (ulong)desc[i].u.kid[0],
1211                       (ulong)desc[i].u.kid[1]);
1212             else if(desc[i].mode==KEYDB_SEARCH_MODE_SHORT_KID)
1213               fprintf(spawn->tochild,"0x%08lX\n",
1214                       (ulong)desc[i].u.kid[1]);
1215             else if(desc[i].mode==KEYDB_SEARCH_MODE_EXACT)
1216               {
1217                 fprintf(spawn->tochild,"0x0000000000000000\n");
1218                 quiet=1;
1219               }
1220             else if(desc[i].mode==KEYDB_SEARCH_MODE_NONE)
1221               continue;
1222             else
1223               BUG();
1224
1225             if(!quiet)
1226               {
1227                 if(keyserver->host)
1228                   log_info(_("requesting key %s from %s server %s\n"),
1229                            keystr_from_desc(&desc[i]),
1230                            keyserver->scheme,keyserver->host);
1231                 else
1232                   log_info(_("requesting key %s from %s\n"),
1233                            keystr_from_desc(&desc[i]),keyserver->uri);
1234               }
1235           }
1236
1237         fprintf(spawn->tochild,"\n");
1238
1239         break;
1240       }
1241
1242     case KS_GETNAME:
1243       {
1244         strlist_t key;
1245
1246         fprintf(spawn->tochild,"COMMAND GETNAME\n\n");
1247
1248         /* Which names do we want? */
1249
1250         for(key=list;key!=NULL;key=key->next)
1251           fprintf(spawn->tochild,"%s\n",key->d);
1252
1253         fprintf(spawn->tochild,"\n");
1254
1255         if(keyserver->host)
1256           log_info(_("searching for names from %s server %s\n"),
1257                    keyserver->scheme,keyserver->host);
1258         else
1259           log_info(_("searching for names from %s\n"),keyserver->uri);
1260
1261         break;
1262       }
1263
1264     case KS_SEND:
1265       {
1266         strlist_t key;
1267
1268         /* Note the extra \n here to send an empty keylist block */
1269         fprintf(spawn->tochild,"COMMAND SEND\n\n\n");
1270
1271         for(key=list;key!=NULL;key=key->next)
1272           {
1273             armor_filter_context_t *afx;
1274             IOBUF buffer = iobuf_temp ();
1275             KBNODE block;
1276
1277             temp=NULL;
1278             add_to_strlist(&temp,key->d);
1279
1280             afx = new_armor_context ();
1281             afx->what = 1;
1282             /* Tell the armor filter to use Unix-style \n line
1283                endings, since we're going to fprintf this to a file
1284                that (on Win32) is open in text mode.  The win32 stdio
1285                will transform the \n to \r\n and we'll end up with the
1286                proper line endings on win32.  This is a no-op on
1287                Unix. */
1288             afx->eol[0] = '\n';
1289             push_armor_filter (afx, buffer);
1290             release_armor_context (afx);
1291
1292             /* TODO: Remove Comment: lines from keys exported this
1293                way? */
1294
1295             if(export_pubkeys_stream (ctrl, buffer,temp,&block,
1296                                       opt.keyserver_options.export_options)==-1)
1297               iobuf_close(buffer);
1298             else
1299               {
1300                 KBNODE node;
1301
1302                 iobuf_flush_temp(buffer);
1303
1304                 merge_keys_and_selfsig(block);
1305
1306                 fprintf(spawn->tochild,"INFO %08lX%08lX BEGIN\n",
1307                         (ulong)block->pkt->pkt.public_key->keyid[0],
1308                         (ulong)block->pkt->pkt.public_key->keyid[1]);
1309
1310                 for(node=block;node;node=node->next)
1311                   {
1312                     switch(node->pkt->pkttype)
1313                       {
1314                       default:
1315                         continue;
1316
1317                       case PKT_PUBLIC_KEY:
1318                       case PKT_PUBLIC_SUBKEY:
1319                         {
1320                           PKT_public_key *pk=node->pkt->pkt.public_key;
1321
1322                           keyid_from_pk(pk,NULL);
1323
1324                           fprintf(spawn->tochild,"%sb:%08lX%08lX:%u:%u:%u:%u:",
1325                                   node->pkt->pkttype==PKT_PUBLIC_KEY?"pu":"su",
1326                                   (ulong)pk->keyid[0],(ulong)pk->keyid[1],
1327                                   pk->pubkey_algo,
1328                                   nbits_from_pk(pk),
1329                                   pk->timestamp,
1330                                   pk->expiredate);
1331
1332                           if(pk->flags.revoked)
1333                             fprintf(spawn->tochild,"r");
1334                           if(pk->has_expired)
1335                             fprintf(spawn->tochild,"e");
1336
1337                           fprintf(spawn->tochild,"\n");
1338                         }
1339                         break;
1340
1341                       case PKT_USER_ID:
1342                         {
1343                           PKT_user_id *uid=node->pkt->pkt.user_id;
1344                           int r;
1345
1346                           if(uid->attrib_data)
1347                             continue;
1348
1349                           fprintf(spawn->tochild,"uid:");
1350
1351                           /* Quote ':', '%', and any 8-bit
1352                              characters */
1353                           for(r=0;r<uid->len;r++)
1354                             {
1355                               if(uid->name[r]==':' || uid->name[r]=='%'
1356                                  || uid->name[r]&0x80)
1357                                 fprintf(spawn->tochild,"%%%02X",
1358                                         (byte)uid->name[r]);
1359                               else
1360                                 fprintf(spawn->tochild,"%c",uid->name[r]);
1361                             }
1362
1363                           fprintf(spawn->tochild,":%u:%u:",
1364                                   uid->created,uid->expiredate);
1365
1366                           if(uid->is_revoked)
1367                             fprintf(spawn->tochild,"r");
1368                           if(uid->is_expired)
1369                             fprintf(spawn->tochild,"e");
1370
1371                           fprintf(spawn->tochild,"\n");
1372                         }
1373                         break;
1374
1375                         /* This bit is really for the benefit of
1376                            people who store their keys in LDAP
1377                            servers.  It makes it easy to do queries
1378                            for things like "all keys signed by
1379                            Isabella". */
1380                       case PKT_SIGNATURE:
1381                         {
1382                           PKT_signature *sig=node->pkt->pkt.signature;
1383
1384                           if(!IS_UID_SIG(sig))
1385                             continue;
1386
1387                           fprintf(spawn->tochild,"sig:%08lX%08lX:%X:%u:%u\n",
1388                                   (ulong)sig->keyid[0],(ulong)sig->keyid[1],
1389                                   sig->sig_class,sig->timestamp,
1390                                   sig->expiredate);
1391                         }
1392                         break;
1393                       }
1394                   }
1395
1396                 fprintf(spawn->tochild,"INFO %08lX%08lX END\n",
1397                         (ulong)block->pkt->pkt.public_key->keyid[0],
1398                         (ulong)block->pkt->pkt.public_key->keyid[1]);
1399
1400                 fprintf(spawn->tochild,"KEY %08lX%08lX BEGIN\n",
1401                         (ulong)block->pkt->pkt.public_key->keyid[0],
1402                         (ulong)block->pkt->pkt.public_key->keyid[1]);
1403                 fwrite(iobuf_get_temp_buffer(buffer),
1404                        iobuf_get_temp_length(buffer),1,spawn->tochild);
1405                 fprintf(spawn->tochild,"KEY %08lX%08lX END\n",
1406                         (ulong)block->pkt->pkt.public_key->keyid[0],
1407                         (ulong)block->pkt->pkt.public_key->keyid[1]);
1408
1409                 iobuf_close(buffer);
1410
1411                 if(keyserver->host)
1412                   log_info(_("sending key %s to %s server %s\n"),
1413                            keystr(block->pkt->pkt.public_key->keyid),
1414                            keyserver->scheme,keyserver->host);
1415                 else
1416                   log_info(_("sending key %s to %s\n"),
1417                            keystr(block->pkt->pkt.public_key->keyid),
1418                            keyserver->uri);
1419
1420                 release_kbnode(block);
1421               }
1422
1423             free_strlist(temp);
1424           }
1425
1426         break;
1427       }
1428
1429     case KS_SEARCH:
1430       {
1431         strlist_t key;
1432
1433         fprintf(spawn->tochild,"COMMAND SEARCH\n\n");
1434
1435         /* Which keys do we want?  Remember that the gpgkeys_ program
1436            is going to lump these together into a search string. */
1437
1438         for(key=list;key!=NULL;key=key->next)
1439           {
1440             fprintf(spawn->tochild,"%s\n",key->d);
1441             if(key!=list)
1442               {
1443                 searchstr=xrealloc(searchstr,
1444                                     strlen(searchstr)+strlen(key->d)+2);
1445                 strcat(searchstr," ");
1446               }
1447             else
1448               {
1449                 searchstr=xmalloc(strlen(key->d)+1);
1450                 searchstr[0]='\0';
1451               }
1452
1453             strcat(searchstr,key->d);
1454           }
1455
1456         fprintf(spawn->tochild,"\n");
1457
1458         if(keyserver->host)
1459           log_info(_("searching for \"%s\" from %s server %s\n"),
1460                    searchstr,keyserver->scheme,keyserver->host);
1461         else
1462           log_info(_("searching for \"%s\" from %s\n"),
1463                    searchstr,keyserver->uri);
1464
1465         break;
1466       }
1467
1468     default:
1469       log_fatal(_("no keyserver action!\n"));
1470       break;
1471     }
1472
1473   /* Done sending, so start reading. */
1474   ret=exec_read(spawn);
1475   if(ret)
1476     goto fail;
1477
1478   /* Now handle the response */
1479
1480   for(;;)
1481     {
1482       int plen;
1483       char *ptr;
1484
1485       maxlen=1024;
1486       if(iobuf_read_line(spawn->fromchild,&line,&buflen,&maxlen)==0)
1487         {
1488           ret = gpg_error_from_syserror ();
1489           goto fail; /* i.e. EOF */
1490         }
1491
1492       ptr=line;
1493
1494       /* remove trailing whitespace */
1495       plen=strlen(ptr);
1496       while(plen>0 && ascii_isspace(ptr[plen-1]))
1497         plen--;
1498       plen[ptr]='\0';
1499
1500       if(*ptr=='\0')
1501         break;
1502
1503       if(ascii_strncasecmp(ptr,"VERSION ",8)==0)
1504         {
1505           gotversion=1;
1506
1507           if(atoi(&ptr[8])!=KEYSERVER_PROTO_VERSION)
1508             {
1509               log_error(_("invalid keyserver protocol (us %d!=handler %d)\n"),
1510                         KEYSERVER_PROTO_VERSION,atoi(&ptr[8]));
1511               goto fail;
1512             }
1513         }
1514       else if(ascii_strncasecmp(ptr,"PROGRAM ",8)==0)
1515         {
1516           if(ascii_strncasecmp(&ptr[8],VERSION,strlen(VERSION))!=0)
1517             log_info(_("WARNING: keyserver handler from a different"
1518                        " version of GnuPG (%s)\n"),&ptr[8]);
1519         }
1520       else if(ascii_strncasecmp(ptr,"OPTION OUTOFBAND",16)==0)
1521         outofband=1; /* Currently the only OPTION */
1522     }
1523
1524   if(!gotversion)
1525     {
1526       log_error(_("keyserver did not send VERSION\n"));
1527       goto fail;
1528     }
1529
1530   if(!outofband)
1531     switch(action)
1532       {
1533       case KS_GET:
1534       case KS_GETNAME:
1535         {
1536           void *stats_handle;
1537
1538           stats_handle=import_new_stats_handle();
1539
1540           /* Slurp up all the key data.  In the future, it might be
1541              nice to look for KEY foo OUTOFBAND and FAILED indicators.
1542              It's harmless to ignore them, but ignoring them does make
1543              gpg complain about "no valid OpenPGP data found".  One
1544              way to do this could be to continue parsing this
1545              line-by-line and make a temp iobuf for each key. */
1546
1547           /* FIXME: Pass CTRL.  */
1548           import_keys_stream (NULL, spawn->fromchild,stats_handle,fpr,fpr_len,
1549                               opt.keyserver_options.import_options);
1550
1551           import_print_stats(stats_handle);
1552           import_release_stats_handle(stats_handle);
1553
1554           break;
1555         }
1556
1557         /* Nothing to do here */
1558       case KS_SEND:
1559         break;
1560
1561       case KS_SEARCH:
1562         //keyserver_search_prompt (ctrl, spawn->fromchild,searchstr);
1563         break;
1564
1565       default:
1566         log_fatal(_("no keyserver action!\n"));
1567         break;
1568       }
1569
1570  fail:
1571   xfree(line);
1572   xfree(searchstr);
1573
1574
1575   *prog=exec_finish(spawn);
1576
1577   return ret;
1578 }
1579
1580
1581
1582
1583 static int
1584 keyserver_work (ctrl_t ctrl,
1585                 enum ks_action action,strlist_t list,KEYDB_SEARCH_DESC *desc,
1586                 int count,unsigned char **fpr,size_t *fpr_len,
1587                 struct keyserver_spec *keyserver)
1588 {
1589   int rc=0,ret=0;
1590
1591   if (!keyserver)
1592     {
1593       log_error (_("no keyserver known (use option --keyserver)\n"));
1594       return gpg_error (GPG_ERR_BAD_URI);
1595     }
1596
1597
1598   rc = keyserver_spawn (ctrl, action, list, desc, count,
1599                         &ret, fpr, fpr_len, keyserver);
1600   if (ret)
1601     {
1602       switch(ret)
1603         {
1604         case KEYSERVER_SCHEME_NOT_FOUND:
1605           log_error(_("no handler for keyserver scheme `%s'\n"),
1606                     keyserver->scheme);
1607           break;
1608
1609         case KEYSERVER_NOT_SUPPORTED:
1610           log_error(_("action `%s' not supported with keyserver "
1611                       "scheme `%s'\n"),
1612                     action==KS_GET?"get":action==KS_SEND?"send":
1613                     action==KS_SEARCH?"search":"unknown",
1614                     keyserver->scheme);
1615           break;
1616
1617         case KEYSERVER_VERSION_ERROR:
1618           log_error(_(GPGKEYS_PREFIX "%s does not support"
1619                       " handler version %d\n"),
1620                     keyserver_typemap(keyserver->scheme),
1621                     KEYSERVER_PROTO_VERSION);
1622           break;
1623
1624         case KEYSERVER_TIMEOUT:
1625           log_error(_("keyserver timed out\n"));
1626           break;
1627
1628         case KEYSERVER_INTERNAL_ERROR:
1629         default:
1630           log_error(_("keyserver internal error\n"));
1631           break;
1632         }
1633
1634       return G10ERR_KEYSERVER;
1635     }
1636
1637   if (rc)
1638     {
1639       log_error (_("keyserver communications error: %s\n"),g10_errstr(rc));
1640
1641       return rc;
1642     }
1643
1644   return 0;
1645 }
1646
1647
1648
1649
1650
1651 int
1652 keyserver_export (ctrl_t ctrl, strlist_t users)
1653 {
1654   gpg_error_t err;
1655   strlist_t sl=NULL;
1656   KEYDB_SEARCH_DESC desc;
1657   int rc=0;
1658
1659   /* Weed out descriptors that we don't support sending */
1660   for(;users;users=users->next)
1661     {
1662       err = classify_user_id (users->d, &desc);
1663       if (err || (desc.mode    != KEYDB_SEARCH_MODE_SHORT_KID
1664                   && desc.mode != KEYDB_SEARCH_MODE_LONG_KID
1665                   && desc.mode != KEYDB_SEARCH_MODE_FPR16
1666                   && desc.mode != KEYDB_SEARCH_MODE_FPR20))
1667         {
1668           log_error(_("\"%s\" not a key ID: skipping\n"),users->d);
1669           continue;
1670         }
1671       else
1672         append_to_strlist(&sl,users->d);
1673     }
1674
1675   if(sl)
1676     {
1677       rc = keyserver_work (ctrl, KS_SEND,sl,NULL,0,NULL,NULL,opt.keyserver);
1678       free_strlist(sl);
1679     }
1680
1681   return rc;
1682 }
1683
1684 int
1685 keyserver_import (ctrl_t ctrl, strlist_t users)
1686 {
1687   gpg_error_t err;
1688   KEYDB_SEARCH_DESC *desc;
1689   int num=100,count=0;
1690   int rc=0;
1691
1692   /* Build a list of key ids */
1693   desc=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
1694
1695   for(;users;users=users->next)
1696     {
1697       err = classify_user_id (users->d, &desc[count]);
1698       if (err || (desc[count].mode    != KEYDB_SEARCH_MODE_SHORT_KID
1699                   && desc[count].mode != KEYDB_SEARCH_MODE_LONG_KID
1700                   && desc[count].mode != KEYDB_SEARCH_MODE_FPR16
1701                   && desc[count].mode != KEYDB_SEARCH_MODE_FPR20))
1702         {
1703           log_error (_("\"%s\" not a key ID: skipping\n"), users->d);
1704           continue;
1705         }
1706
1707       count++;
1708       if(count==num)
1709         {
1710           num+=100;
1711           desc=xrealloc(desc,sizeof(KEYDB_SEARCH_DESC)*num);
1712         }
1713     }
1714
1715   if(count>0)
1716     rc=keyserver_get (ctrl, desc, count, NULL);
1717
1718   xfree(desc);
1719
1720   return rc;
1721 }
1722
1723 int
1724 keyserver_import_fprint (ctrl_t ctrl, const byte *fprint,size_t fprint_len,
1725                          struct keyserver_spec *keyserver)
1726 {
1727   KEYDB_SEARCH_DESC desc;
1728
1729   memset(&desc,0,sizeof(desc));
1730
1731   if(fprint_len==16)
1732     desc.mode=KEYDB_SEARCH_MODE_FPR16;
1733   else if(fprint_len==20)
1734     desc.mode=KEYDB_SEARCH_MODE_FPR20;
1735   else
1736     return -1;
1737
1738   memcpy(desc.u.fpr,fprint,fprint_len);
1739
1740   /* TODO: Warn here if the fingerprint we got doesn't match the one
1741      we asked for? */
1742   return keyserver_get (ctrl, &desc, 1, keyserver);
1743 }
1744
1745 int
1746 keyserver_import_keyid (ctrl_t ctrl,
1747                         u32 *keyid,struct keyserver_spec *keyserver)
1748 {
1749   KEYDB_SEARCH_DESC desc;
1750
1751   memset(&desc,0,sizeof(desc));
1752
1753   desc.mode=KEYDB_SEARCH_MODE_LONG_KID;
1754   desc.u.kid[0]=keyid[0];
1755   desc.u.kid[1]=keyid[1];
1756
1757   return keyserver_get (ctrl, &desc,1, keyserver);
1758 }
1759
1760 /* code mostly stolen from do_export_stream */
1761 static int
1762 keyidlist(strlist_t users,KEYDB_SEARCH_DESC **klist,int *count,int fakev3)
1763 {
1764   int rc=0,ndesc,num=100;
1765   KBNODE keyblock=NULL,node;
1766   KEYDB_HANDLE kdbhd;
1767   KEYDB_SEARCH_DESC *desc;
1768   strlist_t sl;
1769
1770   *count=0;
1771
1772   *klist=xmalloc(sizeof(KEYDB_SEARCH_DESC)*num);
1773
1774   kdbhd=keydb_new ();
1775
1776   if(!users)
1777     {
1778       ndesc = 1;
1779       desc = xmalloc_clear ( ndesc * sizeof *desc);
1780       desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
1781     }
1782   else
1783     {
1784       for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
1785         ;
1786       desc = xmalloc ( ndesc * sizeof *desc);
1787
1788       for (ndesc=0, sl=users; sl; sl = sl->next)
1789         {
1790           gpg_error_t err;
1791           if (!(err = classify_user_id (sl->d, desc+ndesc)))
1792             ndesc++;
1793           else
1794             log_error (_("key \"%s\" not found: %s\n"),
1795                        sl->d, gpg_strerror (err));
1796         }
1797     }
1798
1799   while (!(rc = keydb_search (kdbhd, desc, ndesc)))
1800     {
1801       if (!users)
1802         desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
1803
1804       /* read the keyblock */
1805       rc = keydb_get_keyblock (kdbhd, &keyblock );
1806       if( rc )
1807         {
1808           log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
1809           goto leave;
1810         }
1811
1812       if((node=find_kbnode(keyblock,PKT_PUBLIC_KEY)))
1813         {
1814           /* This is to work around a bug in some keyservers (pksd and
1815              OKS) that calculate v4 RSA keyids as if they were v3 RSA.
1816              The answer is to refresh both the correct v4 keyid
1817              (e.g. 99242560) and the fake v3 keyid (e.g. 68FDDBC7).
1818              This only happens for key refresh using the HKP scheme
1819              and if the refresh-add-fake-v3-keyids keyserver option is
1820              set. */
1821           if(fakev3 && is_RSA(node->pkt->pkt.public_key->pubkey_algo) &&
1822              node->pkt->pkt.public_key->version>=4)
1823             {
1824               (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
1825               v3_keyid (node->pkt->pkt.public_key->pkey[0],
1826                         (*klist)[*count].u.kid);
1827               (*count)++;
1828
1829               if(*count==num)
1830                 {
1831                   num+=100;
1832                   *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
1833                 }
1834             }
1835
1836           /* v4 keys get full fingerprints.  v3 keys get long keyids.
1837              This is because it's easy to calculate any sort of keyid
1838              from a v4 fingerprint, but not a v3 fingerprint. */
1839
1840           if(node->pkt->pkt.public_key->version<4)
1841             {
1842               (*klist)[*count].mode=KEYDB_SEARCH_MODE_LONG_KID;
1843               keyid_from_pk(node->pkt->pkt.public_key,
1844                             (*klist)[*count].u.kid);
1845             }
1846           else
1847             {
1848               size_t dummy;
1849
1850               (*klist)[*count].mode=KEYDB_SEARCH_MODE_FPR20;
1851               fingerprint_from_pk(node->pkt->pkt.public_key,
1852                                   (*klist)[*count].u.fpr,&dummy);
1853             }
1854
1855           /* This is a little hackish, using the skipfncvalue as a
1856              void* pointer to the keyserver spec, but we don't need
1857              the skipfnc here, and it saves having an additional field
1858              for this (which would be wasted space most of the
1859              time). */
1860
1861           (*klist)[*count].skipfncvalue=NULL;
1862
1863           /* Are we honoring preferred keyservers? */
1864           if(opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1865             {
1866               PKT_user_id *uid=NULL;
1867               PKT_signature *sig=NULL;
1868
1869               merge_keys_and_selfsig(keyblock);
1870
1871               for(node=node->next;node;node=node->next)
1872                 {
1873                   if(node->pkt->pkttype==PKT_USER_ID
1874                      && node->pkt->pkt.user_id->is_primary)
1875                     uid=node->pkt->pkt.user_id;
1876                   else if(node->pkt->pkttype==PKT_SIGNATURE
1877                           && node->pkt->pkt.signature->
1878                           flags.chosen_selfsig && uid)
1879                     {
1880                       sig=node->pkt->pkt.signature;
1881                       break;
1882                     }
1883                 }
1884
1885               /* Try and parse the keyserver URL.  If it doesn't work,
1886                  then we end up writing NULL which indicates we are
1887                  the same as any other key. */
1888               if(sig)
1889                 (*klist)[*count].skipfncvalue=parse_preferred_keyserver(sig);
1890             }
1891
1892           (*count)++;
1893
1894           if(*count==num)
1895             {
1896               num+=100;
1897               *klist=xrealloc(*klist,sizeof(KEYDB_SEARCH_DESC)*num);
1898             }
1899         }
1900     }
1901
1902   if(rc==-1)
1903     rc=0;
1904
1905  leave:
1906   if(rc)
1907     xfree(*klist);
1908   xfree(desc);
1909   keydb_release(kdbhd);
1910   release_kbnode(keyblock);
1911
1912   return rc;
1913 }
1914
1915 /* Note this is different than the original HKP refresh.  It allows
1916    usernames to refresh only part of the keyring. */
1917
1918 int
1919 keyserver_refresh (ctrl_t ctrl, strlist_t users)
1920 {
1921   int rc,count,numdesc,fakev3=0;
1922   KEYDB_SEARCH_DESC *desc;
1923   unsigned int options=opt.keyserver_options.import_options;
1924
1925   /* We switch merge-only on during a refresh, as 'refresh' should
1926      never import new keys, even if their keyids match. */
1927   opt.keyserver_options.import_options|=IMPORT_MERGE_ONLY;
1928
1929   /* Similarly, we switch on fast-import, since refresh may make
1930      multiple import sets (due to preferred keyserver URLs).  We don't
1931      want each set to rebuild the trustdb.  Instead we do it once at
1932      the end here. */
1933   opt.keyserver_options.import_options|=IMPORT_FAST;
1934
1935   /* If refresh_add_fake_v3_keyids is on and it's a HKP or MAILTO
1936      scheme, then enable fake v3 keyid generation. */
1937   if((opt.keyserver_options.options&KEYSERVER_ADD_FAKE_V3) && opt.keyserver
1938      && (ascii_strcasecmp(opt.keyserver->scheme,"hkp")==0 ||
1939          ascii_strcasecmp(opt.keyserver->scheme,"mailto")==0))
1940     fakev3=1;
1941
1942   rc=keyidlist(users,&desc,&numdesc,fakev3);
1943   if(rc)
1944     return rc;
1945
1946   count=numdesc;
1947   if(count>0)
1948     {
1949       int i;
1950
1951       /* Try to handle preferred keyserver keys first */
1952       for(i=0;i<numdesc;i++)
1953         {
1954           if(desc[i].skipfncvalue)
1955             {
1956               struct keyserver_spec *keyserver=desc[i].skipfncvalue;
1957
1958               /* We use the keyserver structure we parsed out before.
1959                  Note that a preferred keyserver without a scheme://
1960                  will be interpreted as hkp:// */
1961               rc = keyserver_get (ctrl, &desc[i], 1, keyserver);
1962               if(rc)
1963                 log_info(_("WARNING: unable to refresh key %s"
1964                            " via %s: %s\n"),keystr_from_desc(&desc[i]),
1965                          keyserver->uri,g10_errstr(rc));
1966               else
1967                 {
1968                   /* We got it, so mark it as NONE so we don't try and
1969                      get it again from the regular keyserver. */
1970
1971                   desc[i].mode=KEYDB_SEARCH_MODE_NONE;
1972                   count--;
1973                 }
1974
1975               free_keyserver_spec(keyserver);
1976             }
1977         }
1978     }
1979
1980   if(count>0)
1981     {
1982       if(opt.keyserver)
1983         {
1984           if(count==1)
1985             log_info(_("refreshing 1 key from %s\n"),opt.keyserver->uri);
1986           else
1987             log_info(_("refreshing %d keys from %s\n"),
1988                      count,opt.keyserver->uri);
1989         }
1990
1991       rc=keyserver_get (ctrl, desc, numdesc, NULL);
1992     }
1993
1994   xfree(desc);
1995
1996   opt.keyserver_options.import_options=options;
1997
1998   /* If the original options didn't have fast import, and the trustdb
1999      is dirty, rebuild. */
2000   if(!(opt.keyserver_options.import_options&IMPORT_FAST))
2001     trustdb_check_or_update();
2002
2003   return rc;
2004 }
2005
2006
2007 /* Search for keys on the keyservers.  The patterns are given in the
2008    string list TOKENS.  */
2009 gpg_error_t
2010 keyserver_search (ctrl_t ctrl, strlist_t tokens)
2011 {
2012   gpg_error_t err;
2013   char *searchstr;
2014   struct search_line_handler_parm_s parm;
2015
2016   memset (&parm, 0, sizeof parm);
2017
2018   if (!tokens)
2019     return 0;  /* Return success if no patterns are given.  */
2020
2021   if (!opt.keyserver)
2022     {
2023       log_error (_("no keyserver known (use option --keyserver)\n"));
2024       return gpg_error (GPG_ERR_NO_KEYSERVER);
2025     }
2026
2027   /* Write global options */
2028
2029   /* for(temp=opt.keyserver_options.other;temp;temp=temp->next) */
2030   /*   fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
2031
2032   /* Write per-keyserver options */
2033
2034   /* for(temp=keyserver->options;temp;temp=temp->next) */
2035   /*   fprintf(spawn->tochild,"OPTION %s\n",temp->d); */
2036
2037   {
2038     membuf_t mb;
2039     strlist_t item;
2040
2041     init_membuf (&mb, 1024);
2042     for (item = tokens; item; item = item->next)
2043     {
2044       if (item != tokens)
2045         put_membuf (&mb, " ", 1);
2046       put_membuf_str (&mb, item->d);
2047     }
2048     put_membuf (&mb, "", 1); /* Append Nul.  */
2049     searchstr = get_membuf (&mb, NULL);
2050     if (!searchstr)
2051       {
2052         err = gpg_error_from_syserror ();
2053         goto leave;
2054       }
2055   }
2056   /* FIXME: Enable the next line */
2057   /* log_info (_("searching for \"%s\" from %s\n"), searchstr, keyserver->uri); */
2058
2059   parm.ctrl = ctrl;
2060   if (searchstr)
2061     parm.searchstr_disp = utf8_to_native (searchstr, strlen (searchstr), 0);
2062
2063   err = gpg_dirmngr_ks_search (ctrl, searchstr, search_line_handler, &parm);
2064
2065   if (parm.not_found)
2066     {
2067       if (parm.searchstr_disp)
2068         log_info (_("key \"%s\" not found on keyserver\n"),
2069                   parm.searchstr_disp);
2070       else
2071         log_info (_("key not found on keyserver\n"));
2072     }
2073
2074   if (gpg_err_code (err) == GPG_ERR_NO_KEYSERVER)
2075     log_error (_("no keyserver known (use option --keyserver)\n"));
2076   else if (err)
2077     log_error ("error searching keyserver: %s\n", gpg_strerror (err));
2078
2079   /* switch(ret) */
2080   /*   { */
2081   /*   case KEYSERVER_SCHEME_NOT_FOUND: */
2082   /*     log_error(_("no handler for keyserver scheme `%s'\n"), */
2083   /*        opt.keyserver->scheme); */
2084   /*     break; */
2085
2086   /*   case KEYSERVER_NOT_SUPPORTED: */
2087   /*     log_error(_("action `%s' not supported with keyserver " */
2088   /*          "scheme `%s'\n"), "search", opt.keyserver->scheme); */
2089   /*     break; */
2090
2091   /*   case KEYSERVER_TIMEOUT: */
2092   /*     log_error(_("keyserver timed out\n")); */
2093   /*     break; */
2094
2095   /*   case KEYSERVER_INTERNAL_ERROR: */
2096   /*   default: */
2097   /*     log_error(_("keyserver internal error\n")); */
2098   /*     break; */
2099   /*   } */
2100
2101   /* return gpg_error (GPG_ERR_KEYSERVER); */
2102
2103
2104  leave:
2105   xfree (parm.desc);
2106   xfree (parm.searchstr_disp);
2107   xfree(searchstr);
2108
2109   return err;
2110 }
2111
2112
2113
2114 /* Called using:
2115
2116 show_prompt:
2117 import:
2118 import_foo:
2119 refresh:
2120     rc=keyserver_work (ctrl, KS_GET, NULL, desc, count,
2121                        NULL, NULL, opt.keyserver);
2122
2123
2124 fetch:
2125           rc = keyserver_work (ctrl, KS_GET, NULL, &desc, 1, NULL, NULL, spec);
2126           if(rc)
2127             log_info (_("WARNING: unable to fetch URI %s: %s\n"),
2128                      sl->d,g10_errstr(rc));
2129
2130
2131 export:
2132       rc = keyserver_work (ctrl, KS_SEND,sl,NULL,0,NULL,NULL,opt.keyserver);
2133
2134
2135
2136 import_name:
2137   rc = keyserver_work (ctrl, KS_GETNAME, list, NULL,
2138                        0, fpr, fpr_len, keyserver);
2139
2140 import_ldap:
2141   rc = keyserver_work (ctrl, KS_GETNAME, list, NULL,
2142                        0, fpr, fpr_len, keyserver);
2143
2144  */
2145
2146 static gpg_error_t
2147 keyserver_get (ctrl_t ctrl, KEYDB_SEARCH_DESC *desc, int ndesc,
2148                struct keyserver_spec *keyserver)
2149
2150 {
2151   gpg_error_t err = 0;
2152   char **pattern;
2153   int idx, npat;
2154   estream_t datastream;
2155
2156   /* Create an array filled with a search pattern for each key.  The
2157      array is delimited by a NULL entry.  */
2158   pattern = xtrycalloc (ndesc+1, sizeof *pattern);
2159   if (!pattern)
2160     return gpg_error_from_syserror ();
2161   for (npat=idx=0; idx < ndesc; idx++)
2162     {
2163       int quiet = 0;
2164
2165       if (desc[idx].mode == KEYDB_SEARCH_MODE_FPR20
2166           || desc[idx].mode == KEYDB_SEARCH_MODE_FPR16)
2167         {
2168           pattern[npat] = xtrymalloc (2+2*20+1);
2169           if (!pattern[npat])
2170             err = gpg_error_from_syserror ();
2171           else
2172             {
2173               strcpy (pattern[npat], "0x");
2174               bin2hex (desc[idx].u.fpr,
2175                        desc[idx].mode == KEYDB_SEARCH_MODE_FPR20? 20 : 16,
2176                        pattern[npat]+2);
2177               npat++;
2178             }
2179         }
2180       else if(desc[idx].mode == KEYDB_SEARCH_MODE_LONG_KID)
2181         {
2182           pattern[npat] = xtryasprintf ("0x%08lX%08lX",
2183                                         (ulong)desc[idx].u.kid[0],
2184                                         (ulong)desc[idx].u.kid[1]);
2185           if (!pattern[npat])
2186             err = gpg_error_from_syserror ();
2187           else
2188             npat++;
2189         }
2190       else if(desc[idx].mode == KEYDB_SEARCH_MODE_SHORT_KID)
2191         {
2192           pattern[npat] = xtryasprintf ("0x%08lX", (ulong)desc[idx].u.kid[1]);
2193           if (!pattern[npat])
2194             err = gpg_error_from_syserror ();
2195           else
2196             npat++;
2197         }
2198       else if(desc[idx].mode == KEYDB_SEARCH_MODE_EXACT)
2199         {
2200           /* FIXME: We don't need this.  It is used as a dummy by
2201              keyserver_fetch which passes an entire URL.  Better use a
2202              separate function here. */
2203           pattern[npat] = xtrystrdup ("0x0000000000000000");
2204           if (!pattern[npat])
2205             err = gpg_error_from_syserror ();
2206           else
2207             {
2208               npat++;
2209               quiet = 1;
2210             }
2211         }
2212       else if (desc[idx].mode == KEYDB_SEARCH_MODE_NONE)
2213         continue;
2214       else
2215         BUG();
2216
2217       if (err)
2218         {
2219           for (idx=0; idx < npat; idx++)
2220             xfree (pattern[idx]);
2221           xfree (pattern);
2222           return err;
2223         }
2224
2225       if (!quiet && keyserver)
2226         {
2227           if (keyserver->host)
2228             log_info (_("requesting key %s from %s server %s\n"),
2229                       keystr_from_desc (&desc[idx]),
2230                       keyserver->scheme, keyserver->host);
2231           else
2232             log_info (_("requesting key %s from %s\n"),
2233                       keystr_from_desc (&desc[idx]), keyserver->uri);
2234         }
2235     }
2236
2237
2238   err = gpg_dirmngr_ks_get (ctrl, pattern, &datastream);
2239   for (idx=0; idx < npat; idx++)
2240     xfree (pattern[idx]);
2241   xfree (pattern);
2242   if (!err)
2243     {
2244       void *stats_handle;
2245
2246       stats_handle = import_new_stats_handle();
2247
2248       /* FIXME: Check whether this comment should be moved to dirmngr.
2249
2250          Slurp up all the key data.  In the future, it might be nice
2251          to look for KEY foo OUTOFBAND and FAILED indicators.  It's
2252          harmless to ignore them, but ignoring them does make gpg
2253          complain about "no valid OpenPGP data found".  One way to do
2254          this could be to continue parsing this line-by-line and make
2255          a temp iobuf for each key. */
2256
2257       import_keys_es_stream (ctrl, datastream, stats_handle, NULL, NULL,
2258                              opt.keyserver_options.import_options);
2259
2260       import_print_stats (stats_handle);
2261       import_release_stats_handle (stats_handle);
2262     }
2263   es_fclose (datastream);
2264
2265
2266   return err;
2267 }
2268
2269
2270
2271
2272
2273 int
2274 keyserver_fetch (ctrl_t ctrl, strlist_t urilist)
2275 {
2276   KEYDB_SEARCH_DESC desc;
2277   strlist_t sl;
2278   unsigned int options=opt.keyserver_options.import_options;
2279
2280   /* Switch on fast-import, since fetch can handle more than one
2281      import and we don't want each set to rebuild the trustdb.
2282      Instead we do it once at the end. */
2283   opt.keyserver_options.import_options|=IMPORT_FAST;
2284
2285   /* A dummy desc since we're not actually fetching a particular key
2286      ID */
2287   memset(&desc,0,sizeof(desc));
2288   desc.mode=KEYDB_SEARCH_MODE_EXACT;
2289
2290   for(sl=urilist;sl;sl=sl->next)
2291     {
2292       struct keyserver_spec *spec;
2293
2294       spec=parse_keyserver_uri(sl->d,1,NULL,0);
2295       if(spec)
2296         {
2297           int rc;
2298
2299           rc = keyserver_get (ctrl, &desc, 1, spec);
2300           if(rc)
2301             log_info (_("WARNING: unable to fetch URI %s: %s\n"),
2302                      sl->d,g10_errstr(rc));
2303
2304           free_keyserver_spec(spec);
2305         }
2306       else
2307         log_info (_("WARNING: unable to parse URI %s\n"),sl->d);
2308     }
2309
2310   opt.keyserver_options.import_options=options;
2311
2312   /* If the original options didn't have fast import, and the trustdb
2313      is dirty, rebuild. */
2314   if(!(opt.keyserver_options.import_options&IMPORT_FAST))
2315     trustdb_check_or_update();
2316
2317   return 0;
2318 }
2319
2320 /* Import key in a CERT or pointed to by a CERT */
2321 int
2322 keyserver_import_cert (ctrl_t ctrl,
2323                        const char *name,unsigned char **fpr,size_t *fpr_len)
2324 {
2325   char *domain,*look,*url;
2326   IOBUF key;
2327   int type,rc=G10ERR_GENERAL;
2328
2329   look=xstrdup(name);
2330
2331   domain=strrchr(look,'@');
2332   if(domain)
2333     *domain='.';
2334
2335   type=get_dns_cert(look,max_cert_size,&key,fpr,fpr_len,&url);
2336   if (!type || type == -1)
2337     {
2338       /* There might be an error in res_query which leads to an error
2339          return (-1) in the case that nothing was found.  Thus we take
2340          all errors as key not found.  */
2341       rc = G10ERR_NO_PUBKEY;
2342     }
2343   else if (type==1)
2344     {
2345       int armor_status=opt.no_armor;
2346
2347       /* CERTs are always in binary format */
2348       opt.no_armor=1;
2349
2350       /* FIXME: Pass CTRL.  */
2351       rc = import_keys_stream (NULL, key, NULL, fpr, fpr_len,
2352                                opt.keyserver_options.import_options);
2353
2354       opt.no_armor=armor_status;
2355
2356       iobuf_close(key);
2357     }
2358   else if(type==2 && *fpr)
2359     {
2360       /* We only consider the IPGP type if a fingerprint was provided.
2361          This lets us select the right key regardless of what a URL
2362          points to, or get the key from a keyserver. */
2363       if(url)
2364         {
2365           struct keyserver_spec *spec;
2366
2367           spec=parse_keyserver_uri(url,1,NULL,0);
2368           if(spec)
2369             {
2370               rc = keyserver_import_fprint (ctrl, *fpr,*fpr_len,spec);
2371               free_keyserver_spec(spec);
2372             }
2373         }
2374       else if(opt.keyserver)
2375         {
2376           /* If only a fingerprint is provided, try and fetch it from
2377              our --keyserver */
2378
2379           rc = keyserver_import_fprint (ctrl, *fpr,*fpr_len,opt.keyserver);
2380         }
2381       else
2382         log_info(_("no keyserver known (use option --keyserver)\n"));
2383
2384       /* Give a better string here? "CERT fingerprint for \"%s\"
2385          found, but no keyserver" " known (use option
2386          --keyserver)\n" ? */
2387
2388       xfree(url);
2389     }
2390
2391   xfree(look);
2392
2393   return rc;
2394 }
2395
2396 /* Import key pointed to by a PKA record. Return the requested
2397    fingerprint in fpr. */
2398 int
2399 keyserver_import_pka (ctrl_t ctrl,
2400                       const char *name,unsigned char **fpr,size_t *fpr_len)
2401 {
2402   char *uri;
2403   int rc = G10ERR_NO_PUBKEY;
2404
2405   *fpr = xmalloc (20);
2406   *fpr_len = 20;
2407
2408   uri = get_pka_info (name, *fpr);
2409   if (uri && *uri)
2410     {
2411       /* An URI is available.  Lookup the key. */
2412       struct keyserver_spec *spec;
2413       spec = parse_keyserver_uri (uri, 1, NULL, 0);
2414       if (spec)
2415         {
2416           rc = keyserver_import_fprint (ctrl, *fpr, 20, spec);
2417           free_keyserver_spec (spec);
2418         }
2419       xfree (uri);
2420     }
2421
2422   if (rc)
2423     {
2424       xfree(*fpr);
2425       *fpr = NULL;
2426     }
2427
2428   return rc;
2429 }
2430
2431 /* Import all keys that match name */
2432 int
2433 keyserver_import_name (ctrl_t ctrl, const char *name,
2434                        unsigned char **fpr, size_t *fpr_len,
2435                        struct keyserver_spec *keyserver)
2436 {
2437   strlist_t list=NULL;
2438   int rc;
2439
2440   append_to_strlist(&list,name);
2441
2442   rc = keyserver_work (ctrl, KS_GETNAME, list, NULL,
2443                        0, fpr, fpr_len, keyserver);
2444
2445   free_strlist(list);
2446
2447   return rc;
2448 }
2449
2450 /* Import a key by name using LDAP */
2451 int
2452 keyserver_import_ldap (ctrl_t ctrl,
2453                        const char *name,unsigned char **fpr,size_t *fpr_len)
2454 {
2455   char *domain;
2456   struct keyserver_spec *keyserver;
2457   strlist_t list=NULL;
2458   int rc,hostlen=1;
2459 #ifdef USE_DNS_SRV
2460   struct srventry *srvlist=NULL;
2461   int srvcount,i;
2462   char srvname[MAXDNAME];
2463 #endif
2464
2465   /* Parse out the domain */
2466   domain=strrchr(name,'@');
2467   if(!domain)
2468     return G10ERR_GENERAL;
2469
2470   domain++;
2471
2472   keyserver=xmalloc_clear(sizeof(struct keyserver_spec));
2473   keyserver->scheme=xstrdup("ldap");
2474   keyserver->host=xmalloc(1);
2475   keyserver->host[0]='\0';
2476
2477 #ifdef USE_DNS_SRV
2478   snprintf(srvname,MAXDNAME,"_pgpkey-ldap._tcp.%s",domain);
2479
2480   srvcount=getsrv(srvname,&srvlist);
2481
2482   for(i=0;i<srvcount;i++)
2483     {
2484       hostlen+=strlen(srvlist[i].target)+1;
2485       keyserver->host=xrealloc(keyserver->host,hostlen);
2486
2487       strcat(keyserver->host,srvlist[i].target);
2488
2489       if(srvlist[i].port!=389)
2490         {
2491           char port[7];
2492
2493           hostlen+=6; /* a colon, plus 5 digits (unsigned 16-bit value) */
2494           keyserver->host=xrealloc(keyserver->host,hostlen);
2495
2496           snprintf(port,7,":%u",srvlist[i].port);
2497           strcat(keyserver->host,port);
2498         }
2499
2500       strcat(keyserver->host," ");
2501     }
2502
2503   free(srvlist);
2504 #endif
2505
2506   /* If all else fails, do the PGP Universal trick of
2507      ldap://keys.(domain) */
2508
2509   hostlen+=5+strlen(domain);
2510   keyserver->host=xrealloc(keyserver->host,hostlen);
2511   strcat(keyserver->host,"keys.");
2512   strcat(keyserver->host,domain);
2513
2514   append_to_strlist(&list,name);
2515
2516   rc = keyserver_work (ctrl, KS_GETNAME, list, NULL,
2517                        0, fpr, fpr_len, keyserver);
2518
2519   free_strlist(list);
2520
2521   free_keyserver_spec(keyserver);
2522
2523   return rc;
2524 }