keyserver/gpgkeys_hkp.c

   1 /* gpgkeys_hkp.c - talk to an HKP keyserver
   2  * Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3  *               2009 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  *
  20  * In addition, as a special exception, the Free Software Foundation
  21  * gives permission to link the code of the keyserver helper tools:
  22  * gpgkeys_ldap, gpgkeys_curl and gpgkeys_hkp with the OpenSSL
  23  * project's "OpenSSL" library (or with modified versions of it that
  24  * use the same license as the "OpenSSL" library), and distribute the
  25  * linked executables.  You must obey the GNU General Public License
  26  * in all respects for all of the code used other than "OpenSSL".  If
  27  * you modify this file, you may extend this exception to your version
  28  * of the file, but you are not obligated to do so.  If you do not
  29  * wish to do so, delete this exception statement from your version.
  30  */
  31
  32 #include <config.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <stdlib.h>
  36 #include <errno.h>
  37 #include <unistd.h>
  38 #ifdef HAVE_GETOPT_H
  39 #include <getopt.h>
  40 #endif
  41 #ifdef HAVE_LIBCURL
  42 #include <curl/curl.h>
  43 #else
  44 #include "curl-shim.h"
  45 #endif
  46 #ifdef USE_DNS_SRV
  47 #include "srv.h"
  48 #endif
  49 #include "keyserver.h"
  50 #include "ksutil.h"
  51
  52 extern char *optarg;
  53 extern int optind;
  54
  55 static FILE *input,*output,*console;
  56 static CURL *curl;
  57 static struct ks_options *opt;
  58 static char errorbuffer[CURL_ERROR_SIZE];
  59 static char *proto,*port;
  60
  61 static size_t
  62 curl_mrindex_writer(const void *ptr,size_t size,size_t nmemb,void *stream)
  63 {
  64   static int checked=0,swallow=0;
  65
  66   if(!checked)
  67     {
  68       /* If the document begins with a '<', assume it's a HTML
  69          response, which we don't support.  Discard the whole message
  70          body.  GPG can handle it, but this is an optimization to deal
  71          with it on this side of the pipe.  */
  72       const char *buf=ptr;
  73       if(buf[0]=='<')
  74         swallow=1;
  75
  76       checked=1;
  77     }
  78
  79   if(swallow || fwrite(ptr,size,nmemb,stream)==nmemb)
  80     return size*nmemb;
  81   else
  82     return 0;
  83 }
  84
  85 /* Append but avoid creating a double slash // in the path. */
  86 static char *
  87 append_path(char *dest,const char *src)
  88 {
  89   size_t n=strlen(dest);
  90
  91   if(src[0]=='/' && n>0 && dest[n-1]=='/')
  92     dest[n-1]='\0';
  93
  94   return strcat(dest,src);
  95 }
  96
  97 int
  98 send_key(int *r_eof)
  99 {
 100   CURLcode res;
 101   char request[MAX_URL+15];
 102   int begin=0,end=0,ret=KEYSERVER_INTERNAL_ERROR;
 103   char keyid[17],state[6];
 104   char line[MAX_LINE];
 105   char *key=NULL,*encoded_key=NULL;
 106   size_t keylen=0,keymax=0;
 107
 108   /* Read and throw away input until we see the BEGIN */
 109
 110   while(fgets(line,MAX_LINE,input)!=NULL)
 111     if(sscanf(line,"KEY%*[ ]%16s%*[ ]%5s\n",keyid,state)==2
 112        && strcmp(state,"BEGIN")==0)
 113       {
 114         begin=1;
 115         break;
 116       }
 117
 118   if(!begin)
 119     {
 120       /* i.e. eof before the KEY BEGIN was found.  This isn't an
 121          error. */
 122       *r_eof=1;
 123       ret=KEYSERVER_OK;
 124       goto fail;
 125     }
 126
 127   /* Now slurp up everything until we see the END */
 128
 129   while(fgets(line,MAX_LINE,input))
 130     if(sscanf(line,"KEY%*[ ]%16s%*[ ]%3s\n",keyid,state)==2
 131        && strcmp(state,"END")==0)
 132       {
 133         end=1;
 134         break;
 135       }
 136     else
 137       {
 138         if(strlen(line)+keylen>keymax)
 139           {
 140             char *tmp;
 141
 142             keymax+=200;
 143             tmp=realloc(key,keymax+1);
 144             if(!tmp)
 145               {
 146                 free(key);
 147                 fprintf(console,"gpgkeys: out of memory\n");
 148                 ret=KEYSERVER_NO_MEMORY;
 149                 goto fail;
 150               }
 151
 152             key=tmp;
 153           }
 154
 155         strcpy(&key[keylen],line);
 156         keylen+=strlen(line);
 157       }
 158
 159   if(!end)
 160     {
 161       fprintf(console,"gpgkeys: no KEY %s END found\n",keyid);
 162       *r_eof=1;
 163       ret=KEYSERVER_KEY_INCOMPLETE;
 164       goto fail;
 165     }
 166
 167   encoded_key=curl_escape(key,keylen);
 168   if(!encoded_key)
 169     {
 170       fprintf(console,"gpgkeys: out of memory\n");
 171       ret=KEYSERVER_NO_MEMORY;
 172       goto fail;
 173     }
 174
 175   free(key);
 176
 177   key=malloc(8+strlen(encoded_key)+1);
 178   if(!key)
 179     {
 180       fprintf(console,"gpgkeys: out of memory\n");
 181       ret=KEYSERVER_NO_MEMORY;
 182       goto fail;
 183     }
 184
 185   strcpy(key,"keytext=");
 186   strcat(key,encoded_key);
 187
 188   strcpy(request,proto);
 189   strcat(request,"://");
 190   strcat(request,opt->host);
 191   strcat(request,":");
 192   strcat(request,port);
 193   strcat(request,opt->path);
 194   /* request is MAX_URL+15 bytes long - MAX_URL covers the whole URL,
 195      including any supplied path.  The 15 covers /pks/add. */
 196   append_path(request,"/pks/add");
 197
 198   if(opt->verbose>2)
 199     fprintf(console,"gpgkeys: HTTP URL is `%s'\n",request);
 200
 201   curl_easy_setopt(curl,CURLOPT_URL,request);
 202   curl_easy_setopt(curl,CURLOPT_POST,1L);
 203   curl_easy_setopt(curl,CURLOPT_POSTFIELDS,key);
 204   curl_easy_setopt(curl,CURLOPT_FAILONERROR,1L);
 205
 206   res=curl_easy_perform(curl);
 207   if(res!=0)
 208     {
 209       fprintf(console,"gpgkeys: HTTP post error %d: %s\n",res,errorbuffer);
 210       ret=curl_err_to_gpg_err(res);
 211       goto fail;
 212     }
 213   else
 214     fprintf(output,"\nKEY %s SENT\n",keyid);
 215
 216   ret=KEYSERVER_OK;
 217
 218  fail:
 219   free(key);
 220   curl_free(encoded_key);
 221
 222   if(ret!=0 && begin)
 223     fprintf(output,"KEY %s FAILED %d\n",keyid,ret);
 224
 225   return ret;
 226 }
 227
 228 static int
 229 get_key(char *getkey)
 230 {
 231   CURLcode res;
 232   char request[MAX_URL+60];
 233   char *offset;
 234   struct curl_writer_ctx ctx;
 235
 236   memset(&ctx,0,sizeof(ctx));
 237
 238   /* Build the search string.  HKP only uses the short key IDs. */
 239
 240   if(strncmp(getkey,"0x",2)==0)
 241     getkey+=2;
 242
 243   fprintf(output,"KEY 0x%s BEGIN\n",getkey);
 244
 245   if(strlen(getkey)==32)
 246     {
 247       fprintf(console,
 248               "gpgkeys: HKP keyservers do not support v3 fingerprints\n");
 249       fprintf(output,"KEY 0x%s FAILED %d\n",getkey,KEYSERVER_NOT_SUPPORTED);
 250       return KEYSERVER_NOT_SUPPORTED;
 251     }
 252
 253   strcpy(request,proto);
 254   strcat(request,"://");
 255   strcat(request,opt->host);
 256   strcat(request,":");
 257   strcat(request,port);
 258   strcat(request,opt->path);
 259   /* request is MAX_URL+55 bytes long - MAX_URL covers the whole URL,
 260      including any supplied path.  The 60 overcovers this /pks/... etc
 261      string plus the 8 bytes of key id */
 262   append_path(request,"/pks/lookup?op=get&options=mr&search=0x");
 263
 264   /* fingerprint or long key id.  Take the last 8 characters and treat
 265      it like a short key id */
 266   if(strlen(getkey)>8)
 267     offset=&getkey[strlen(getkey)-8];
 268   else
 269     offset=getkey;
 270
 271   strcat(request,offset);
 272
 273   if(opt->verbose>2)
 274     fprintf(console,"gpgkeys: HTTP URL is `%s'\n",request);
 275
 276   curl_easy_setopt(curl,CURLOPT_URL,request);
 277   curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,curl_writer);
 278   ctx.stream=output;
 279   curl_easy_setopt(curl,CURLOPT_FILE,&ctx);
 280
 281   res=curl_easy_perform(curl);
 282   if(res!=CURLE_OK)
 283     {
 284       fprintf(console,"gpgkeys: HTTP fetch error %d: %s\n",res,errorbuffer);
 285       fprintf(output,"\nKEY 0x%s FAILED %d\n",getkey,curl_err_to_gpg_err(res));
 286     }
 287   else
 288     {
 289       curl_writer_finalize(&ctx);
 290       if(!ctx.flags.done)
 291         {
 292           fprintf(console,"gpgkeys: key %s not found on keyserver\n",getkey);
 293           fprintf(output,"\nKEY 0x%s FAILED %d\n",
 294                   getkey,KEYSERVER_KEY_NOT_FOUND);
 295         }
 296       else
 297         fprintf(output,"\nKEY 0x%s END\n",getkey);
 298     }
 299
 300   return KEYSERVER_OK;
 301 }
 302
 303 static int
 304 get_name(const char *getkey)
 305 {
 306   CURLcode res;
 307   char *request=NULL;
 308   char *searchkey_encoded;
 309   int ret=KEYSERVER_INTERNAL_ERROR;
 310   struct curl_writer_ctx ctx;
 311
 312   memset(&ctx,0,sizeof(ctx));
 313
 314   searchkey_encoded=curl_escape((char *)getkey,0);
 315   if(!searchkey_encoded)
 316     {
 317       fprintf(console,"gpgkeys: out of memory\n");
 318       ret=KEYSERVER_NO_MEMORY;
 319       goto fail;
 320     }
 321
 322   request=malloc(MAX_URL+60+strlen(searchkey_encoded));
 323   if(!request)
 324     {
 325       fprintf(console,"gpgkeys: out of memory\n");
 326       ret=KEYSERVER_NO_MEMORY;
 327       goto fail;
 328     }
 329
 330   fprintf(output,"NAME %s BEGIN\n",getkey);
 331
 332   strcpy(request,proto);
 333   strcat(request,"://");
 334   strcat(request,opt->host);
 335   strcat(request,":");
 336   strcat(request,port);
 337   strcat(request,opt->path);
 338   append_path(request,"/pks/lookup?op=get&options=mr&search=");
 339   strcat(request,searchkey_encoded);
 340
 341   if(opt->action==KS_GETNAME)
 342     strcat(request,"&exact=on");
 343
 344   if(opt->verbose>2)
 345     fprintf(console,"gpgkeys: HTTP URL is `%s'\n",request);
 346
 347   curl_easy_setopt(curl,CURLOPT_URL,request);
 348   curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,curl_writer);
 349   ctx.stream=output;
 350   curl_easy_setopt(curl,CURLOPT_FILE,&ctx);
 351
 352   res=curl_easy_perform(curl);
 353   if(res!=CURLE_OK)
 354     {
 355       fprintf(console,"gpgkeys: HTTP fetch error %d: %s\n",res,errorbuffer);
 356       ret=curl_err_to_gpg_err(res);
 357     }
 358   else
 359     {
 360       curl_writer_finalize(&ctx);
 361       if(!ctx.flags.done)
 362         {
 363           fprintf(console,"gpgkeys: key %s not found on keyserver\n",getkey);
 364           ret=KEYSERVER_KEY_NOT_FOUND;
 365         }
 366       else
 367         {
 368           fprintf(output,"\nNAME %s END\n",getkey);
 369           ret=KEYSERVER_OK;
 370         }
 371     }
 372
 373  fail:
 374   curl_free(searchkey_encoded);
 375   free(request);
 376
 377   if(ret!=KEYSERVER_OK)
 378     fprintf(output,"\nNAME %s FAILED %d\n",getkey,ret);
 379
 380   return ret;
 381 }
 382
 383 static int
 384 search_key(const char *searchkey)
 385 {
 386   CURLcode res;
 387   char *request=NULL;
 388   char *searchkey_encoded;
 389   int ret=KEYSERVER_INTERNAL_ERROR;
 390   enum ks_search_type search_type;
 391
 392   search_type=classify_ks_search(&searchkey);
 393
 394   if(opt->debug)
 395     fprintf(console,"gpgkeys: search type is %d, and key is \"%s\"\n",
 396             search_type,searchkey);
 397
 398   searchkey_encoded=curl_escape((char *)searchkey,0);
 399   if(!searchkey_encoded)
 400     {
 401       fprintf(console,"gpgkeys: out of memory\n");
 402       ret=KEYSERVER_NO_MEMORY;
 403       goto fail;
 404     }
 405
 406   request=malloc(MAX_URL+60+strlen(searchkey_encoded));
 407   if(!request)
 408     {
 409       fprintf(console,"gpgkeys: out of memory\n");
 410       ret=KEYSERVER_NO_MEMORY;
 411       goto fail;
 412     }
 413
 414   fprintf(output,"SEARCH %s BEGIN\n",searchkey);
 415
 416   strcpy(request,proto);
 417   strcat(request,"://");
 418   strcat(request,opt->host);
 419   strcat(request,":");
 420   strcat(request,port);
 421   strcat(request,opt->path);
 422   append_path(request,"/pks/lookup?op=index&options=mr&search=");
 423
 424   /* HKP keyservers like the 0x to be present when searching by
 425      keyid */
 426   if(search_type==KS_SEARCH_KEYID_SHORT || search_type==KS_SEARCH_KEYID_LONG)
 427     strcat(request,"0x");
 428
 429   strcat(request,searchkey_encoded);
 430
 431   if(search_type!=KS_SEARCH_SUBSTR)
 432     strcat(request,"&exact=on");
 433
 434   if(opt->verbose>2)
 435     fprintf(console,"gpgkeys: HTTP URL is `%s'\n",request);
 436
 437   curl_easy_setopt(curl,CURLOPT_URL,request);
 438   curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,curl_mrindex_writer);
 439   curl_easy_setopt(curl,CURLOPT_FILE,output);
 440
 441   res=curl_easy_perform(curl);
 442   if(res!=0)
 443     {
 444       fprintf(console,"gpgkeys: HTTP search error %d: %s\n",res,errorbuffer);
 445       ret=curl_err_to_gpg_err(res);
 446     }
 447   else
 448     {
 449       fprintf(output,"\nSEARCH %s END\n",searchkey);
 450       ret=KEYSERVER_OK;
 451     }
 452
 453  fail:
 454
 455   curl_free(searchkey_encoded);
 456   free(request);
 457
 458   if(ret!=KEYSERVER_OK)
 459     fprintf(output,"\nSEARCH %s FAILED %d\n",searchkey,ret);
 460
 461   return ret;
 462 }
 463
 464 void
 465 fail_all(struct keylist *keylist,int err)
 466 {
 467   if(!keylist)
 468     return;
 469
 470   if(opt->action==KS_SEARCH)
 471     {
 472       fprintf(output,"SEARCH ");
 473       while(keylist)
 474         {
 475           fprintf(output,"%s ",keylist->str);
 476           keylist=keylist->next;
 477         }
 478       fprintf(output,"FAILED %d\n",err);
 479     }
 480   else
 481     while(keylist)
 482       {
 483         fprintf(output,"KEY %s FAILED %d\n",keylist->str,err);
 484         keylist=keylist->next;
 485       }
 486 }
 487
 488 #ifdef HAVE_LIBCURL
 489 /* If there is a SRV record, take the highest ranked possibility.
 490    This is a hack, as we don't proceed downwards. */
 491 static void
 492 srv_replace(void)
 493 {
 494 #ifdef USE_DNS_SRV
 495   struct srventry *srvlist=NULL;
 496   int srvcount;
 497
 498   if(1+strlen(opt->scheme)+6+strlen(opt->host)+1<=MAXDNAME)
 499     {
 500       char srvname[MAXDNAME];
 501
 502       strcpy(srvname,"_");
 503       strcat(srvname,opt->scheme);
 504       strcat(srvname,"._tcp.");
 505       strcat(srvname,opt->host);
 506       srvcount=getsrv(srvname,&srvlist);
 507     }
 508
 509   if(srvlist)
 510     {
 511       char *newname,*newport;
 512
 513       newname=strdup(srvlist->target);
 514       newport=malloc(MAX_PORT);
 515       if(newname && newport)
 516         {
 517           free(opt->host);
 518           free(opt->port);
 519           opt->host=newname;
 520           snprintf(newport,MAX_PORT,"%u",srvlist->port);
 521           opt->port=newport;
 522         }
 523       else
 524         {
 525           free(newname);
 526           free(newport);
 527         }
 528     }
 529 #endif
 530 }
 531 #endif
 532
 533 static void
 534 show_help (FILE *fp)
 535 {
 536   fprintf (fp,"-h, --help\thelp\n");
 537   fprintf (fp,"-V\t\tmachine readable version\n");
 538   fprintf (fp,"--version\thuman readable version\n");
 539   fprintf (fp,"-o\t\toutput to this file\n");
 540 }
 541
 542 int
 543 main(int argc,char *argv[])
 544 {
 545   int arg,ret=KEYSERVER_INTERNAL_ERROR,try_srv=1;
 546   char line[MAX_LINE];
 547   int failed=0;
 548   struct keylist *keylist=NULL,*keyptr=NULL;
 549   char *proxy=NULL;
 550   struct curl_slist *headers=NULL;
 551
 552   console=stderr;
 553
 554   /* Kludge to implement standard GNU options.  */
 555   if (argc > 1 && !strcmp (argv[1], "--version"))
 556     {
 557       printf ("gpgkeys_hkp (GnuPG) %s\n", VERSION);
 558       printf ("Uses: %s\n", curl_version());
 559       return 0;
 560     }
 561   else if (argc > 1 && !strcmp (argv[1], "--help"))
 562     {
 563       show_help (stdout);
 564       return 0;
 565     }
 566
 567   while((arg=getopt(argc,argv,"hVo:"))!=-1)
 568     switch(arg)
 569       {
 570       default:
 571       case 'h':
 572         show_help (console);
 573         return KEYSERVER_OK;
 574
 575       case 'V':
 576         fprintf(stdout,"%d\n%s\n",KEYSERVER_PROTO_VERSION,VERSION);
 577         return KEYSERVER_OK;
 578
 579       case 'o':
 580         output=fopen(optarg,"w");
 581         if(output==NULL)
 582           {
 583             fprintf(console,"gpgkeys: Cannot open output file `%s': %s\n",
 584                     optarg,strerror(errno));
 585             return KEYSERVER_INTERNAL_ERROR;
 586           }
 587
 588         break;
 589       }
 590
 591   if(argc>optind)
 592     {
 593       input=fopen(argv[optind],"r");
 594       if(input==NULL)
 595         {
 596           fprintf(console,"gpgkeys: Cannot open input file `%s': %s\n",
 597                   argv[optind],strerror(errno));
 598           return KEYSERVER_INTERNAL_ERROR;
 599         }
 600     }
 601
 602   if(input==NULL)
 603     input=stdin;
 604
 605   if(output==NULL)
 606     output=stdout;
 607
 608   opt=init_ks_options();
 609   if(!opt)
 610     return KEYSERVER_NO_MEMORY;
 611
 612   /* Get the command and info block */
 613
 614   while(fgets(line,MAX_LINE,input)!=NULL)
 615     {
 616       int err;
 617       char option[MAX_OPTION+1];
 618
 619       if(line[0]=='\n')
 620         break;
 621
 622       err=parse_ks_options(line,opt);
 623       if(err>0)
 624         {
 625           ret=err;
 626           goto fail;
 627         }
 628       else if(err==0)
 629         continue;
 630
 631       if(sscanf(line,"OPTION %" MKSTRING(MAX_OPTION) "s\n",option)==1)
 632         {
 633           int no=0;
 634           char *start=&option[0];
 635
 636           option[MAX_OPTION]='\0';
 637
 638           if(strncasecmp(option,"no-",3)==0)
 639             {
 640               no=1;
 641               start=&option[3];
 642             }
 643
 644           if(strncasecmp(start,"http-proxy",10)==0)
 645             {
 646               if(no)
 647                 {
 648                   free(proxy);
 649                   proxy=strdup("");
 650                 }
 651               else if(start[10]=='=')
 652                 {
 653                   if(strlen(&start[11])<MAX_PROXY)
 654                     {
 655                       free(proxy);
 656                       proxy=strdup(&start[11]);
 657                     }
 658                 }
 659             }
 660           else if(strcasecmp(start,"try-dns-srv")==0)
 661             {
 662               if(no)
 663                 try_srv=0;
 664               else
 665                 try_srv=1;
 666             }
 667
 668           continue;
 669         }
 670     }
 671
 672   if(!opt->scheme)
 673     {
 674       fprintf(console,"gpgkeys: no scheme supplied!\n");
 675       ret=KEYSERVER_SCHEME_NOT_FOUND;
 676       goto fail;
 677     }
 678
 679   if(ks_strcasecmp(opt->scheme,"hkps")==0)
 680     {
 681       proto="https";
 682       port="443";
 683     }
 684   else
 685     {
 686       proto="http";
 687       port="11371";
 688     }
 689
 690   if(!opt->host)
 691     {
 692       fprintf(console,"gpgkeys: no keyserver host provided\n");
 693       goto fail;
 694     }
 695
 696   if(opt->timeout && register_timeout()==-1)
 697     {
 698       fprintf(console,"gpgkeys: unable to register timeout handler\n");
 699       return KEYSERVER_INTERNAL_ERROR;
 700     }
 701
 702   curl_global_init(CURL_GLOBAL_DEFAULT);
 703   curl=curl_easy_init();
 704   if(!curl)
 705     {
 706       fprintf(console,"gpgkeys: unable to initialize curl\n");
 707       ret=KEYSERVER_INTERNAL_ERROR;
 708       goto fail;
 709     }
 710
 711   /* If the user gives a :port, then disable SRV.  The semantics of a
 712      specified port and SRV do not play well together. */
 713   if(opt->port)
 714     port=opt->port;
 715   else if(try_srv)
 716     {
 717 #ifdef HAVE_LIBCURL
 718       /* We're using libcurl, so fake SRV support via our wrapper.
 719          This isn't as good as true SRV support, as we do not try all
 720          possible targets at one particular level and work our way
 721          down the list, but it's better than nothing. */
 722       srv_replace();
 723 #else
 724       /* We're using our internal curl shim, so we can use its (true)
 725          SRV support.  Obviously, CURLOPT_SRVTAG_GPG_HACK isn't a real
 726          libcurl option.  It's specific to our shim. */
 727       curl_easy_setopt(curl,CURLOPT_SRVTAG_GPG_HACK,opt->scheme);
 728 #endif
 729     }
 730
 731   curl_easy_setopt(curl,CURLOPT_ERRORBUFFER,errorbuffer);
 732
 733   if(opt->auth)
 734     curl_easy_setopt(curl,CURLOPT_USERPWD,opt->auth);
 735
 736   if(opt->debug)
 737     {
 738       fprintf(console,"gpgkeys: curl version = %s\n",curl_version());
 739       curl_easy_setopt(curl,CURLOPT_STDERR,console);
 740       curl_easy_setopt(curl,CURLOPT_VERBOSE,1L);
 741     }
 742
 743   curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,(long)opt->flags.check_cert);
 744   curl_easy_setopt(curl,CURLOPT_CAINFO,opt->ca_cert_file);
 745
 746   /* Avoid caches to get the most recent copy of the key.  This is bug
 747      #1061.  In pre-curl versions of the code, we didn't do it.  Then
 748      we did do it (as a curl default) until curl changed the default.
 749      Now we're doing it again, but in such a way that changing
 750      defaults in the future won't impact us.  We set both the Pragma
 751      and Cache-Control versions of the header, so we're good with both
 752      HTTP 1.0 and 1.1. */
 753   headers=curl_slist_append(headers,"Pragma: no-cache");
 754   if(headers)
 755     headers=curl_slist_append(headers,"Cache-Control: no-cache");
 756
 757   if(!headers)
 758     {
 759       fprintf(console,"gpgkeys: out of memory when building HTTP headers\n");
 760       ret=KEYSERVER_NO_MEMORY;
 761       goto fail;
 762     }
 763
 764   curl_easy_setopt(curl,CURLOPT_HTTPHEADER,headers);
 765
 766   if(proxy)
 767     curl_easy_setopt(curl,CURLOPT_PROXY,proxy);
 768
 769   /* If it's a GET or a SEARCH, the next thing to come in is the
 770      keyids.  If it's a SEND, then there are no keyids. */
 771
 772   if(opt->action==KS_SEND)
 773     while(fgets(line,MAX_LINE,input)!=NULL && line[0]!='\n');
 774   else if(opt->action==KS_GET
 775           || opt->action==KS_GETNAME || opt->action==KS_SEARCH)
 776     {
 777       for(;;)
 778         {
 779           struct keylist *work;
 780
 781           if(fgets(line,MAX_LINE,input)==NULL)
 782             break;
 783           else
 784             {
 785               if(line[0]=='\n' || line[0]=='\0')
 786                 break;
 787
 788               work=malloc(sizeof(struct keylist));
 789               if(work==NULL)
 790                 {
 791                   fprintf(console,"gpgkeys: out of memory while "
 792                           "building key list\n");
 793                   ret=KEYSERVER_NO_MEMORY;
 794                   goto fail;
 795                 }
 796
 797               strcpy(work->str,line);
 798
 799               /* Trim the trailing \n */
 800               work->str[strlen(line)-1]='\0';
 801
 802               work->next=NULL;
 803
 804               /* Always attach at the end to keep the list in proper
 805                  order for searching */
 806               if(keylist==NULL)
 807                 keylist=work;
 808               else
 809                 keyptr->next=work;
 810
 811               keyptr=work;
 812             }
 813         }
 814     }
 815   else
 816     {
 817       fprintf(console,"gpgkeys: no keyserver command specified\n");
 818       goto fail;
 819     }
 820
 821   /* Send the response */
 822
 823   fprintf(output,"VERSION %d\n",KEYSERVER_PROTO_VERSION);
 824   fprintf(output,"PROGRAM %s\n\n",VERSION);
 825
 826   if(opt->verbose>1)
 827     {
 828       fprintf(console,"Host:\t\t%s\n",opt->host);
 829       if(opt->port)
 830         fprintf(console,"Port:\t\t%s\n",opt->port);
 831       if(strcmp(opt->path,"/")!=0)
 832         fprintf(console,"Path:\t\t%s\n",opt->path);
 833       fprintf(console,"Command:\t%s\n",ks_action_to_string(opt->action));
 834     }
 835
 836   if(opt->action==KS_GET)
 837     {
 838       keyptr=keylist;
 839
 840       while(keyptr!=NULL)
 841         {
 842           set_timeout(opt->timeout);
 843
 844           if(get_key(keyptr->str)!=KEYSERVER_OK)
 845             failed++;
 846
 847           keyptr=keyptr->next;
 848         }
 849     }
 850   else if(opt->action==KS_GETNAME)
 851     {
 852       keyptr=keylist;
 853
 854       while(keyptr!=NULL)
 855         {
 856           set_timeout(opt->timeout);
 857
 858           if(get_name(keyptr->str)!=KEYSERVER_OK)
 859             failed++;
 860
 861           keyptr=keyptr->next;
 862         }
 863     }
 864   else if(opt->action==KS_SEND)
 865     {
 866       int myeof=0;
 867
 868       do
 869         {
 870           set_timeout(opt->timeout);
 871
 872           if(send_key(&myeof)!=KEYSERVER_OK)
 873             failed++;
 874         }
 875       while(!myeof);
 876     }
 877   else if(opt->action==KS_SEARCH)
 878     {
 879       char *searchkey=NULL;
 880       int len=0;
 881
 882       set_timeout(opt->timeout);
 883
 884       /* To search, we stick a space in between each key to search
 885          for. */
 886
 887       keyptr=keylist;
 888       while(keyptr!=NULL)
 889         {
 890           len+=strlen(keyptr->str)+1;
 891           keyptr=keyptr->next;
 892         }
 893
 894       searchkey=malloc(len+1);
 895       if(searchkey==NULL)
 896         {
 897           ret=KEYSERVER_NO_MEMORY;
 898           fail_all(keylist,KEYSERVER_NO_MEMORY);
 899           goto fail;
 900         }
 901
 902       searchkey[0]='\0';
 903
 904       keyptr=keylist;
 905       while(keyptr!=NULL)
 906         {
 907           strcat(searchkey,keyptr->str);
 908           strcat(searchkey," ");
 909           keyptr=keyptr->next;
 910         }
 911
 912       /* Nail that last space */
 913       if(*searchkey)
 914         searchkey[strlen(searchkey)-1]='\0';
 915
 916       if(search_key(searchkey)!=KEYSERVER_OK)
 917         failed++;
 918
 919       free(searchkey);
 920     }
 921   else
 922     abort();
 923
 924   if(!failed)
 925     ret=KEYSERVER_OK;
 926
 927  fail:
 928   while(keylist!=NULL)
 929     {
 930       struct keylist *current=keylist;
 931       keylist=keylist->next;
 932       free(current);
 933     }
 934
 935   if(input!=stdin)
 936     fclose(input);
 937
 938   if(output!=stdout)
 939     fclose(output);
 940
 941   free_ks_options(opt);
 942
 943   curl_slist_free_all(headers);
 944
 945   if(curl)
 946     curl_easy_cleanup(curl);
 947
 948   free(proxy);
 949
 950   return ret;
 951 }