keyserver/gpgkeys_curl.c

   1 /* gpgkeys_curl.c - fetch a key via libcurl
   2  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  * In addition, as a special exception, the Free Software Foundation
  20  * gives permission to link the code of the keyserver helper tools:
  21  * gpgkeys_ldap, gpgkeys_curl and gpgkeys_hkp with the OpenSSL
  22  * project's "OpenSSL" library (or with modified versions of it that
  23  * use the same license as the "OpenSSL" library), and distribute the
  24  * linked executables.  You must obey the GNU General Public License
  25  * in all respects for all of the code used other than "OpenSSL".  If
  26  * you modify this file, you may extend this exception to your version
  27  * of the file, but you are not obligated to do so.  If you do not
  28  * wish to do so, delete this exception statement from your version.
  29  */
  30
  31 #include <config.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <stdlib.h>
  35 #include <errno.h>
  36 #include <unistd.h>
  37 #ifdef HAVE_GETOPT_H
  38 #include <getopt.h>
  39 #endif
  40 #ifdef HAVE_LIBCURL
  41 #include <curl/curl.h>
  42 #else
  43 #include "curl-shim.h"
  44 #endif
  45 #include "keyserver.h"
  46 #include "ksutil.h"
  47
  48 extern char *optarg;
  49 extern int optind;
  50
  51 static FILE *input,*output,*console;
  52 static CURL *curl;
  53 static struct ks_options *opt;
  54
  55 static int
  56 get_key(char *getkey)
  57 {
  58   CURLcode res;
  59   char errorbuffer[CURL_ERROR_SIZE];
  60   char request[MAX_URL];
  61   struct curl_writer_ctx ctx;
  62
  63   memset(&ctx,0,sizeof(ctx));
  64
  65   if(strncmp(getkey,"0x",2)==0)
  66     getkey+=2;
  67
  68   fprintf(output,"KEY 0x%s BEGIN\n",getkey);
  69
  70   sprintf(request,"%s://%s%s%s%s",opt->scheme,opt->host,
  71           opt->port?":":"",opt->port?opt->port:"",opt->path?opt->path:"/");
  72
  73   curl_easy_setopt(curl,CURLOPT_URL,request);
  74   curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,curl_writer);
  75   ctx.stream=output;
  76   curl_easy_setopt(curl,CURLOPT_FILE,&ctx);
  77   curl_easy_setopt(curl,CURLOPT_ERRORBUFFER,errorbuffer);
  78
  79   res=curl_easy_perform(curl);
  80   if(res!=CURLE_OK)
  81     {
  82       fprintf(console,"gpgkeys: %s fetch error %d: %s\n",opt->scheme,
  83               res,errorbuffer);
  84       fprintf(output,"\nKEY 0x%s FAILED %d\n",getkey,curl_err_to_gpg_err(res));
  85     }
  86   else
  87     {
  88       curl_writer_finalize(&ctx);
  89       if(!ctx.flags.done)
  90         {
  91           fprintf(console,"gpgkeys: no key data found for %s\n",request);
  92           fprintf(output,"\nKEY 0x%s FAILED %d\n",
  93                   getkey,KEYSERVER_KEY_NOT_FOUND);
  94         }
  95       else
  96         fprintf(output,"\nKEY 0x%s END\n",getkey);
  97     }
  98
  99   return curl_err_to_gpg_err(res);
 100 }
 101
 102 static void
 103 show_help (FILE *fp)
 104 {
 105   fprintf (fp,"-h, --help\thelp\n");
 106   fprintf (fp,"-V\t\tmachine readable version\n");
 107   fprintf (fp,"--version\thuman readable version\n");
 108   fprintf (fp,"-o\t\toutput to this file\n");
 109 }
 110
 111 int
 112 main(int argc,char *argv[])
 113 {
 114   int arg,ret=KEYSERVER_INTERNAL_ERROR,i;
 115   char line[MAX_LINE];
 116   char *thekey=NULL;
 117   long follow_redirects=5;
 118   char *proxy=NULL;
 119   curl_version_info_data *curldata;
 120
 121   console=stderr;
 122
 123   /* Kludge to implement standard GNU options.  */
 124   if (argc > 1 && !strcmp (argv[1], "--version"))
 125     {
 126       printf ("gpgkeys_curl (GnuPG) %s\n", VERSION);
 127       printf ("Uses: %s\n", curl_version());
 128       return 0;
 129     }
 130   else if (argc > 1 && !strcmp (argv[1], "--help"))
 131     {
 132       show_help (stdout);
 133       return 0;
 134     }
 135
 136   while((arg=getopt(argc,argv,"hVo:"))!=-1)
 137     switch(arg)
 138       {
 139       default:
 140       case 'h':
 141         show_help (console);
 142         return KEYSERVER_OK;
 143
 144       case 'V':
 145         fprintf(stdout,"%d\n%s\n",KEYSERVER_PROTO_VERSION,VERSION);
 146         return KEYSERVER_OK;
 147
 148       case 'o':
 149         output=fopen(optarg,"wb");
 150         if(output==NULL)
 151           {
 152             fprintf(console,"gpgkeys: Cannot open output file `%s': %s\n",
 153                     optarg,strerror(errno));
 154             return KEYSERVER_INTERNAL_ERROR;
 155           }
 156
 157         break;
 158       }
 159
 160   if(argc>optind)
 161     {
 162       input=fopen(argv[optind],"r");
 163       if(input==NULL)
 164         {
 165           fprintf(console,"gpgkeys: Cannot open input file `%s': %s\n",
 166                   argv[optind],strerror(errno));
 167           return KEYSERVER_INTERNAL_ERROR;
 168         }
 169     }
 170
 171   if(input==NULL)
 172     input=stdin;
 173
 174   if(output==NULL)
 175     output=stdout;
 176
 177   opt=init_ks_options();
 178   if(!opt)
 179     return KEYSERVER_NO_MEMORY;
 180
 181   /* Get the command and info block */
 182
 183   while(fgets(line,MAX_LINE,input)!=NULL)
 184     {
 185       int err;
 186       char option[MAX_OPTION+1];
 187
 188       if(line[0]=='\n')
 189         break;
 190
 191       err=parse_ks_options(line,opt);
 192       if(err>0)
 193         {
 194           ret=err;
 195           goto fail;
 196         }
 197       else if(err==0)
 198         continue;
 199
 200       if(sscanf(line,"OPTION %" MKSTRING(MAX_OPTION) "s\n",option)==1)
 201         {
 202           int no=0;
 203           char *start=&option[0];
 204
 205           option[MAX_OPTION]='\0';
 206
 207           if(strncasecmp(option,"no-",3)==0)
 208             {
 209               no=1;
 210               start=&option[3];
 211             }
 212
 213           if(strncasecmp(start,"http-proxy",10)==0)
 214             {
 215               /* Safe to not check the return code of strdup() here.
 216                  If it fails, we simply won't use a proxy. */
 217               if(no)
 218                 {
 219                   free(proxy);
 220                   proxy=strdup("");
 221                 }
 222               else if(start[10]=='=')
 223                 {
 224                   if(strlen(&start[11])<MAX_PROXY)
 225                     {
 226                       free(proxy);
 227                       proxy=strdup(&start[11]);
 228                     }
 229                 }
 230             }
 231           else if(strncasecmp(start,"follow-redirects",16)==0)
 232             {
 233               if(no)
 234                 follow_redirects=0;
 235               else if(start[16]=='=')
 236                 follow_redirects=atoi(&start[17]);
 237               else if(start[16]=='\0')
 238                 follow_redirects=-1;
 239             }
 240
 241           continue;
 242         }
 243     }
 244
 245   if(!opt->scheme)
 246     {
 247       fprintf(console,"gpgkeys: no scheme supplied!\n");
 248       ret=KEYSERVER_SCHEME_NOT_FOUND;
 249       goto fail;
 250     }
 251
 252   if(!opt->host)
 253     {
 254       fprintf(console,"gpgkeys: no keyserver host provided\n");
 255       goto fail;
 256     }
 257
 258   if(opt->timeout && register_timeout()==-1)
 259     {
 260       fprintf(console,"gpgkeys: unable to register timeout handler\n");
 261       return KEYSERVER_INTERNAL_ERROR;
 262     }
 263
 264   curl_global_init(CURL_GLOBAL_DEFAULT);
 265
 266   curl=curl_easy_init();
 267   if(!curl)
 268     {
 269       fprintf(console,"gpgkeys: unable to initialize curl\n");
 270       ret=KEYSERVER_INTERNAL_ERROR;
 271       goto fail;
 272     }
 273
 274   /* Make sure we have the protocol the user is asking for so we can
 275      print a nicer error message. */
 276   curldata=curl_version_info(CURLVERSION_NOW);
 277   for(i=0;curldata->protocols[i];i++)
 278     if(strcasecmp(curldata->protocols[i],opt->scheme)==0)
 279       break;
 280
 281   if(curldata->protocols[i]==NULL)
 282     {
 283       fprintf(console,"gpgkeys: protocol `%s' not supported\n",opt->scheme);
 284       ret=KEYSERVER_SCHEME_NOT_FOUND;
 285       goto fail;
 286     }
 287
 288   if(follow_redirects)
 289     {
 290       curl_easy_setopt(curl,CURLOPT_FOLLOWLOCATION,1L);
 291       if(follow_redirects>0)
 292         curl_easy_setopt(curl,CURLOPT_MAXREDIRS,follow_redirects);
 293     }
 294
 295   if(opt->auth)
 296     curl_easy_setopt(curl,CURLOPT_USERPWD,opt->auth);
 297
 298   if(opt->debug)
 299     {
 300       fprintf(console,"gpgkeys: curl version = %s\n",curl_version());
 301       curl_easy_setopt(curl,CURLOPT_STDERR,console);
 302       curl_easy_setopt(curl,CURLOPT_VERBOSE,1L);
 303     }
 304
 305   curl_easy_setopt(curl,CURLOPT_SSL_VERIFYPEER,(long)opt->flags.check_cert);
 306   curl_easy_setopt(curl,CURLOPT_CAINFO,opt->ca_cert_file);
 307
 308   if(proxy)
 309     curl_easy_setopt(curl,CURLOPT_PROXY,proxy);
 310
 311   /* If it's a GET or a SEARCH, the next thing to come in is the
 312      keyids.  If it's a SEND, then there are no keyids. */
 313
 314   if(opt->action==KS_GET)
 315     {
 316       /* Eat the rest of the file */
 317       for(;;)
 318         {
 319           if(fgets(line,MAX_LINE,input)==NULL)
 320             break;
 321           else
 322             {
 323               if(line[0]=='\n' || line[0]=='\0')
 324                 break;
 325
 326               if(!thekey)
 327                 {
 328                   thekey=strdup(line);
 329                   if(!thekey)
 330                     {
 331                       fprintf(console,"gpgkeys: out of memory while "
 332                               "building key list\n");
 333                       ret=KEYSERVER_NO_MEMORY;
 334                       goto fail;
 335                     }
 336
 337                   /* Trim the trailing \n */
 338                   thekey[strlen(line)-1]='\0';
 339                 }
 340             }
 341         }
 342     }
 343   else
 344     {
 345       fprintf(console,
 346               "gpgkeys: this keyserver type only supports key retrieval\n");
 347       goto fail;
 348     }
 349
 350   if(!thekey)
 351     {
 352       fprintf(console,"gpgkeys: invalid keyserver instructions\n");
 353       goto fail;
 354     }
 355
 356   /* Send the response */
 357
 358   fprintf(output,"VERSION %d\n",KEYSERVER_PROTO_VERSION);
 359   fprintf(output,"PROGRAM %s\n\n",VERSION);
 360
 361   if(opt->verbose)
 362     {
 363       fprintf(console,"Scheme:\t\t%s\n",opt->scheme);
 364       fprintf(console,"Host:\t\t%s\n",opt->host);
 365       if(opt->port)
 366         fprintf(console,"Port:\t\t%s\n",opt->port);
 367       if(opt->path)
 368         fprintf(console,"Path:\t\t%s\n",opt->path);
 369       fprintf(console,"Command:\tGET\n");
 370     }
 371
 372   set_timeout(opt->timeout);
 373
 374   ret=get_key(thekey);
 375
 376  fail:
 377
 378   free(thekey);
 379
 380   if(input!=stdin)
 381     fclose(input);
 382
 383   if(output!=stdout)
 384     fclose(output);
 385
 386   free_ks_options(opt);
 387
 388   if(curl)
 389     curl_easy_cleanup(curl);
 390
 391   free(proxy);
 392
 393   curl_global_cleanup();
 394
 395   return ret;
 396 }