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