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