g10/keyserver.c

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