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