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