2001-12-06 22:54:04 +01:00
|
|
|
/* keyserver.c - generic keyserver code
|
|
|
|
* Copyright (C) 2001 Free Software Foundation, Inc.
|
|
|
|
*
|
|
|
|
* This file is part of GnuPG.
|
|
|
|
*
|
|
|
|
* GnuPG is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* GnuPG is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <config.h>
|
2001-12-25 19:04:09 +01:00
|
|
|
#include <ctype.h>
|
|
|
|
#include <stdio.h>
|
2001-12-06 22:54:04 +01:00
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
2001-12-25 19:04:09 +01:00
|
|
|
|
|
|
|
#include "filter.h"
|
2001-12-06 22:54:04 +01:00
|
|
|
#include "keydb.h"
|
|
|
|
#include "status.h"
|
2001-12-22 00:06:02 +01:00
|
|
|
#include "exec.h"
|
2001-12-06 22:54:04 +01:00
|
|
|
#include "main.h"
|
2001-12-25 19:04:09 +01:00
|
|
|
#include "i18n.h"
|
2001-12-06 22:54:04 +01:00
|
|
|
#include "hkp.h"
|
2001-12-25 19:04:09 +01:00
|
|
|
#include "iobuf.h"
|
|
|
|
#include "memory.h"
|
|
|
|
#include "options.h"
|
|
|
|
#include "packet.h"
|
|
|
|
#include "keyserver-internal.h"
|
2002-01-02 18:51:34 +01:00
|
|
|
#include "util.h"
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
#define KEYSERVER_PROTO_VERSION 0
|
|
|
|
|
|
|
|
#define GET 0
|
|
|
|
#define SEND 1
|
|
|
|
#define SEARCH 2
|
|
|
|
|
2001-12-15 19:27:13 +01:00
|
|
|
void
|
|
|
|
parse_keyserver_options(char *options)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
char *tok="";
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if(strcasecmp(tok,"fast-import")==0)
|
|
|
|
opt.keyserver_options.fast_import=1;
|
|
|
|
else if(strcasecmp(tok,"no-fast-import")==0)
|
|
|
|
opt.keyserver_options.fast_import=0;
|
|
|
|
else if(strcasecmp(tok,"include-revoked")==0)
|
|
|
|
opt.keyserver_options.include_revoked=1;
|
|
|
|
else if(strcasecmp(tok,"no-include-revoked")==0)
|
|
|
|
opt.keyserver_options.include_revoked=0;
|
|
|
|
else if(strcasecmp(tok,"include-disabled")==0)
|
|
|
|
opt.keyserver_options.include_disabled=1;
|
|
|
|
else if(strcasecmp(tok,"no-include-disabled")==0)
|
|
|
|
opt.keyserver_options.include_disabled=0;
|
2001-12-22 00:06:02 +01:00
|
|
|
#ifdef EXEC_TEMPFILE_ONLY
|
2001-12-06 22:54:04 +01:00
|
|
|
else if(strcasecmp(tok,"use-temp-files")==0 ||
|
|
|
|
strcasecmp(tok,"no-use-temp-files")==0)
|
|
|
|
log_info(_("Warning: keyserver option \"%s\" is not used "
|
|
|
|
"on this platform\n"),tok);
|
|
|
|
#else
|
|
|
|
else if(strcasecmp(tok,"use-temp-files")==0)
|
|
|
|
opt.keyserver_options.use_temp_files=1;
|
|
|
|
else if(strcasecmp(tok,"no-use-temp-files")==0)
|
|
|
|
opt.keyserver_options.use_temp_files=0;
|
|
|
|
#endif
|
|
|
|
else if(strcasecmp(tok,"keep-temp-files")==0)
|
|
|
|
opt.keyserver_options.keep_temp_files=1;
|
|
|
|
else if(strcasecmp(tok,"no-keep-temp-files")==0)
|
|
|
|
opt.keyserver_options.keep_temp_files=0;
|
|
|
|
else if(strcasecmp(tok,"verbose")==0)
|
|
|
|
opt.keyserver_options.verbose++;
|
|
|
|
else if(strcasecmp(tok,"no-verbose")==0)
|
|
|
|
opt.keyserver_options.verbose--;
|
|
|
|
else if(strcasecmp(tok,"honor-http-proxy")==0)
|
|
|
|
opt.honor_http_proxy=1;
|
|
|
|
else if(strcasecmp(tok,"no-honor-http-proxy")==0)
|
|
|
|
opt.honor_http_proxy=0;
|
|
|
|
else if(strlen(tok)>0)
|
|
|
|
add_to_strlist(&opt.keyserver_options.other,tok);
|
|
|
|
|
|
|
|
tok=strsep(&options," ,");
|
|
|
|
}
|
|
|
|
while(tok!=NULL);
|
|
|
|
}
|
|
|
|
|
2001-12-15 19:27:13 +01:00
|
|
|
int
|
|
|
|
parse_keyserver_uri(char *uri)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
/* Get the scheme */
|
|
|
|
|
|
|
|
opt.keyserver_scheme=strsep(&uri,":");
|
|
|
|
if(uri==NULL)
|
|
|
|
{
|
|
|
|
uri=opt.keyserver_scheme;
|
|
|
|
opt.keyserver_scheme="x-hkp";
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Skip the "//", if any */
|
|
|
|
if(strlen(uri)>2 && uri[0]=='/' && uri[1]=='/')
|
|
|
|
uri+=2;
|
|
|
|
|
|
|
|
/* Get the host */
|
|
|
|
opt.keyserver_host=strsep(&uri,":/");
|
|
|
|
if(uri==NULL)
|
|
|
|
opt.keyserver_port="0";
|
|
|
|
else
|
|
|
|
{
|
2001-12-20 06:02:30 +01:00
|
|
|
char *ch;
|
2001-12-19 00:10:46 +01:00
|
|
|
|
2001-12-06 22:54:04 +01:00
|
|
|
/* Get the port */
|
|
|
|
opt.keyserver_port=strsep(&uri,"/");
|
2001-12-19 00:10:46 +01:00
|
|
|
|
|
|
|
/* Ports are digits only */
|
|
|
|
ch=opt.keyserver_port;
|
|
|
|
while(*ch!='\0')
|
|
|
|
{
|
|
|
|
if(!isdigit(*ch))
|
|
|
|
return G10ERR_BAD_URI;
|
|
|
|
|
|
|
|
ch++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(strlen(opt.keyserver_port)==0 ||
|
|
|
|
atoi(opt.keyserver_port)<1 || atoi(opt.keyserver_port)>65535)
|
|
|
|
return G10ERR_BAD_URI;
|
2001-12-06 22:54:04 +01:00
|
|
|
}
|
|
|
|
|
2001-12-19 00:10:46 +01:00
|
|
|
/* (any path part of the URI is discarded for now) */
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
if(opt.keyserver_scheme[0]=='\0' || opt.keyserver_host[0]=='\0')
|
|
|
|
return G10ERR_BAD_URI;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Unquote only the delimiter character */
|
2001-12-15 19:27:13 +01:00
|
|
|
static void
|
|
|
|
printunquoted(char *string,char delim)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
char *ch=string;
|
|
|
|
|
|
|
|
while(*ch)
|
|
|
|
{
|
|
|
|
if(*ch=='\\')
|
|
|
|
{
|
|
|
|
int c;
|
|
|
|
|
|
|
|
sscanf(ch,"\\x%02X",&c);
|
|
|
|
if(c==delim)
|
|
|
|
{
|
|
|
|
printf("%c",c);
|
|
|
|
ch+=3;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
fputc(*ch,stdout);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
fputc(*ch,stdout);
|
|
|
|
|
|
|
|
ch++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-12-15 19:27:13 +01:00
|
|
|
static int
|
|
|
|
print_keyinfo(int count,char *keystring,u32 *keyid)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
char *certid,*userid,*keytype,*tok;
|
|
|
|
int flags,keysize=0;
|
|
|
|
time_t createtime=0,expiretime=0,modifytime=0;
|
|
|
|
|
|
|
|
if((certid=strsep(&keystring,":"))==NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* Ideally this is the long key ID, but HKP uses the short key
|
|
|
|
ID. */
|
|
|
|
if(sscanf(certid,"%08lX%08lX",(ulong *)&keyid[0],(ulong *)&keyid[1])!=2)
|
|
|
|
{
|
|
|
|
keyid[0]=0;
|
|
|
|
if(sscanf(certid,"%08lX",(ulong *)&keyid[1])!=1)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if((tok=strsep(&keystring,":"))==NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
userid=utf8_to_native(tok,strlen(tok),0);
|
|
|
|
|
|
|
|
if((tok=strsep(&keystring,":"))==NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
flags=atoi(tok);
|
|
|
|
|
|
|
|
if((tok=strsep(&keystring,":"))==NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
createtime=atoi(tok);
|
|
|
|
|
|
|
|
if((tok=strsep(&keystring,":"))==NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
expiretime=atoi(tok);
|
|
|
|
|
|
|
|
if((tok=strsep(&keystring,":"))==NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
modifytime=atoi(tok);
|
|
|
|
|
|
|
|
if((keytype=strsep(&keystring,":"))==NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* The last one */
|
|
|
|
if(keystring!=NULL)
|
|
|
|
keysize=atoi(keystring);
|
|
|
|
|
|
|
|
printf("(%d)\t",count);
|
|
|
|
|
2001-12-18 00:10:07 +01:00
|
|
|
/* No need to check for control characters, as utf8_to_native does
|
|
|
|
this for us. */
|
2001-12-06 22:54:04 +01:00
|
|
|
printunquoted(userid,':');
|
|
|
|
|
|
|
|
if(flags&1)
|
|
|
|
printf(" (revoked)");
|
|
|
|
if(flags&2)
|
|
|
|
printf(" (disabled)");
|
|
|
|
|
|
|
|
if(keytype[0])
|
|
|
|
printf(" %s",keytype);
|
|
|
|
|
|
|
|
if(keysize>0)
|
|
|
|
printf(" %d",keysize);
|
|
|
|
|
|
|
|
printf("\n\t created %s,",strtimestamp(createtime));
|
|
|
|
|
|
|
|
if(expiretime>0)
|
|
|
|
printf(" expires %s,",strtimestamp(expiretime));
|
|
|
|
|
|
|
|
printf(" keyid %s\n",certid);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
#define KEYSERVER_ARGS_KEEP " -o \"%O\" \"%I\""
|
|
|
|
#define KEYSERVER_ARGS_NOKEEP " -o \"%o\" \"%i\""
|
2001-12-15 19:27:13 +01:00
|
|
|
|
|
|
|
static int
|
2001-12-22 00:06:02 +01:00
|
|
|
keyserver_spawn(int action,STRLIST list,u32 (*kidlist)[2],int count,int *prog)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
2001-12-28 17:34:01 +01:00
|
|
|
int ret=0,i,gotversion=0,outofband=0;
|
2001-12-06 22:54:04 +01:00
|
|
|
STRLIST temp;
|
|
|
|
unsigned int maxlen=256,buflen;
|
2001-12-22 00:06:02 +01:00
|
|
|
char *command=NULL,*searchstr=NULL;
|
2001-12-06 22:54:04 +01:00
|
|
|
byte *line=NULL;
|
2001-12-22 00:06:02 +01:00
|
|
|
struct exec_info *spawn;
|
2001-12-20 06:02:30 +01:00
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
#ifdef EXEC_TEMPFILE_ONLY
|
|
|
|
opt.keyserver_options.use_temp_files=1;
|
|
|
|
#endif
|
2001-12-20 06:02:30 +01:00
|
|
|
|
2001-12-06 22:54:04 +01:00
|
|
|
/* Build the filename for the helper to execute */
|
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
command=m_alloc(strlen("gpgkeys_")+strlen(opt.keyserver_scheme)+1);
|
|
|
|
strcpy(command,"gpgkeys_");
|
|
|
|
strcat(command,opt.keyserver_scheme);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
if(opt.keyserver_options.use_temp_files)
|
|
|
|
{
|
2001-12-22 00:06:02 +01:00
|
|
|
if(opt.keyserver_options.keep_temp_files)
|
2001-12-20 06:02:30 +01:00
|
|
|
{
|
2001-12-22 00:06:02 +01:00
|
|
|
command=m_realloc(command,strlen(command)+
|
|
|
|
strlen(KEYSERVER_ARGS_KEEP)+1);
|
|
|
|
strcat(command,KEYSERVER_ARGS_KEEP);
|
2001-12-06 22:54:04 +01:00
|
|
|
}
|
2001-12-22 00:06:02 +01:00
|
|
|
else
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
2001-12-22 00:06:02 +01:00
|
|
|
command=m_realloc(command,strlen(command)+
|
|
|
|
strlen(KEYSERVER_ARGS_NOKEEP)+1);
|
|
|
|
strcat(command,KEYSERVER_ARGS_NOKEEP);
|
2001-12-06 22:54:04 +01:00
|
|
|
}
|
2001-12-22 00:06:02 +01:00
|
|
|
|
|
|
|
ret=exec_write(&spawn,NULL,command,0,0);
|
2001-12-06 22:54:04 +01:00
|
|
|
}
|
|
|
|
else
|
2001-12-22 00:06:02 +01:00
|
|
|
ret=exec_write(&spawn,command,NULL,0,0);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
if(ret)
|
2001-12-29 05:43:11 +01:00
|
|
|
return ret;
|
2001-12-06 22:54:04 +01:00
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"# This is a gpg keyserver communications file\n");
|
|
|
|
fprintf(spawn->tochild,"VERSION %d\n",KEYSERVER_PROTO_VERSION);
|
|
|
|
fprintf(spawn->tochild,"PROGRAM %s\n",VERSION);
|
|
|
|
fprintf(spawn->tochild,"HOST %s\n",opt.keyserver_host);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
if(atoi(opt.keyserver_port)>0)
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"PORT %s\n",opt.keyserver_port);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
/* Write options */
|
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"OPTION %sinclude-revoked\n",
|
2001-12-06 22:54:04 +01:00
|
|
|
opt.keyserver_options.include_revoked?"":"no-");
|
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"OPTION %sinclude-disabled\n",
|
2001-12-06 22:54:04 +01:00
|
|
|
opt.keyserver_options.include_disabled?"":"no-");
|
|
|
|
|
|
|
|
for(i=0;i<opt.keyserver_options.verbose;i++)
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"OPTION verbose\n");
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
temp=opt.keyserver_options.other;
|
|
|
|
|
|
|
|
for(;temp;temp=temp->next)
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"OPTION %s\n",temp->d);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
switch(action)
|
|
|
|
{
|
|
|
|
case GET:
|
|
|
|
{
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"COMMAND GET\n\n");
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
/* Which keys do we want? */
|
|
|
|
|
|
|
|
for(i=0;i<count;i++)
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"0x%08lX%08lX\n",
|
2001-12-06 22:54:04 +01:00
|
|
|
(ulong)kidlist[i][0],(ulong)kidlist[i][1]);
|
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"\n");
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SEND:
|
|
|
|
{
|
2001-12-22 14:04:24 +01:00
|
|
|
STRLIST key;
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
/* Note the extra \n here to send an empty keylist block */
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"COMMAND SEND\n\n\n");
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
for(key=list;key!=NULL;key=key->next)
|
|
|
|
{
|
|
|
|
armor_filter_context_t afx;
|
|
|
|
IOBUF buffer=iobuf_temp();
|
|
|
|
|
|
|
|
temp=NULL;
|
|
|
|
add_to_strlist(&temp,key->d);
|
|
|
|
|
|
|
|
memset(&afx,0,sizeof(afx));
|
|
|
|
afx.what=1;
|
|
|
|
iobuf_push_filter(buffer,armor_filter,&afx);
|
|
|
|
|
|
|
|
if(export_pubkeys_stream(buffer,key,1)==-1)
|
|
|
|
iobuf_close(buffer);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
iobuf_flush_temp(buffer);
|
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"KEY %s BEGIN\n",key->d);
|
2001-12-06 22:54:04 +01:00
|
|
|
fwrite(iobuf_get_temp_buffer(buffer),
|
2001-12-22 00:06:02 +01:00
|
|
|
iobuf_get_temp_length(buffer),1,spawn->tochild);
|
|
|
|
fprintf(spawn->tochild,"KEY %s END\n",key->d);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
iobuf_close(buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
free_strlist(temp);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SEARCH:
|
|
|
|
{
|
|
|
|
STRLIST key;
|
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"COMMAND SEARCH\n\n");
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
/* Which keys do we want? Remember that the gpgkeys_ program
|
|
|
|
is going to lump these together into a search string. */
|
|
|
|
|
|
|
|
for(key=list;key!=NULL;key=key->next)
|
|
|
|
{
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"%s\n",key->d);
|
2001-12-06 22:54:04 +01:00
|
|
|
if(key!=list)
|
|
|
|
{
|
|
|
|
searchstr=m_realloc(searchstr,
|
|
|
|
strlen(searchstr)+strlen(key->d)+2);
|
|
|
|
strcat(searchstr," ");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
searchstr=m_alloc(strlen(key->d)+1);
|
|
|
|
searchstr[0]='\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
strcat(searchstr,key->d);
|
|
|
|
}
|
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
fprintf(spawn->tochild,"\n");
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
log_fatal(_("no keyserver action!\n"));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-12-22 00:06:02 +01:00
|
|
|
/* Done sending, so start reading. */
|
|
|
|
ret=exec_read(spawn);
|
|
|
|
if(ret)
|
|
|
|
goto fail;
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
/* Now handle the response */
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
2001-12-22 00:06:02 +01:00
|
|
|
if(iobuf_read_line(spawn->fromchild,&line,&buflen,&maxlen)==0)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
ret=G10ERR_READ_FILE;
|
|
|
|
goto fail; /* i.e. EOF */
|
|
|
|
}
|
|
|
|
|
|
|
|
if(strncasecmp(line,"VERSION ",8)==0)
|
|
|
|
{
|
|
|
|
gotversion=1;
|
|
|
|
|
|
|
|
if(atoi(&line[8])!=KEYSERVER_PROTO_VERSION)
|
|
|
|
{
|
2001-12-17 23:48:52 +01:00
|
|
|
log_error(_("invalid keyserver protocol (us %d!=handler %d)\n"),
|
2001-12-06 22:54:04 +01:00
|
|
|
KEYSERVER_PROTO_VERSION,atoi(&line[8]));
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(strncasecmp(line,"PROGRAM ",8)==0)
|
|
|
|
{
|
|
|
|
line[strlen(line)-1]='\0';
|
|
|
|
if(strcasecmp(&line[8],VERSION)!=0)
|
|
|
|
log_info(_("Warning: keyserver handler from a different "
|
|
|
|
"version of GnuPG (%s)\n"),&line[8]);
|
|
|
|
}
|
2001-12-28 17:34:01 +01:00
|
|
|
|
|
|
|
/* Currently the only OPTION */
|
|
|
|
if(strncasecmp(line,"OPTION OUTOFBAND",16)==0)
|
|
|
|
outofband=1;
|
2001-12-06 22:54:04 +01:00
|
|
|
}
|
|
|
|
while(line[0]!='\n');
|
|
|
|
|
|
|
|
if(!gotversion)
|
|
|
|
{
|
2001-12-27 21:48:05 +01:00
|
|
|
log_error(_("keyserver did not send VERSION\n"));
|
2001-12-06 22:54:04 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2001-12-28 17:34:01 +01:00
|
|
|
if(!outofband)
|
|
|
|
switch(action)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
2001-12-28 17:34:01 +01:00
|
|
|
case GET:
|
|
|
|
{
|
|
|
|
void *stats_handle;
|
|
|
|
|
|
|
|
stats_handle=import_new_stats_handle();
|
2001-12-06 22:54:04 +01:00
|
|
|
|
2001-12-28 17:34:01 +01:00
|
|
|
/* Slurp up all the key data. In the future, it might be nice
|
|
|
|
to look for KEY foo OUTOFBAND and FAILED indicators. It's
|
|
|
|
harmless to ignore them, but ignoring them does make gpg
|
|
|
|
complain about "no valid OpenPGP data found". One way to
|
|
|
|
do this could be to continue parsing this line-by-line and
|
|
|
|
make a temp iobuf for each key. */
|
2001-12-06 22:54:04 +01:00
|
|
|
|
2001-12-28 17:34:01 +01:00
|
|
|
import_keys_stream(spawn->fromchild,
|
|
|
|
opt.keyserver_options.fast_import,stats_handle);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
2001-12-28 17:34:01 +01:00
|
|
|
import_print_stats(stats_handle);
|
|
|
|
import_release_stats_handle(stats_handle);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
2001-12-28 17:34:01 +01:00
|
|
|
break;
|
|
|
|
}
|
2001-12-06 22:54:04 +01:00
|
|
|
|
2001-12-28 17:34:01 +01:00
|
|
|
/* Nothing to do here */
|
|
|
|
case SEND:
|
2001-12-06 22:54:04 +01:00
|
|
|
break;
|
|
|
|
|
2001-12-28 17:34:01 +01:00
|
|
|
case SEARCH:
|
|
|
|
{
|
|
|
|
line=NULL;
|
|
|
|
buflen = 0;
|
|
|
|
maxlen = 80;
|
|
|
|
/* Look for the COUNT line */
|
|
|
|
do
|
|
|
|
{
|
|
|
|
if(iobuf_read_line(spawn->fromchild,&line,&buflen,&maxlen)==0)
|
|
|
|
{
|
|
|
|
ret=G10ERR_READ_FILE;
|
|
|
|
goto fail; /* i.e. EOF */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while(sscanf(line,"COUNT %d\n",&i)!=1);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
2001-12-28 17:34:01 +01:00
|
|
|
keyserver_search_prompt(spawn->fromchild,i,searchstr);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
2001-12-28 17:34:01 +01:00
|
|
|
break;
|
|
|
|
}
|
2001-12-06 22:54:04 +01:00
|
|
|
|
2001-12-28 17:34:01 +01:00
|
|
|
default:
|
|
|
|
log_fatal(_("no keyserver action!\n"));
|
2001-12-06 22:54:04 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
fail:
|
2001-12-27 21:48:05 +01:00
|
|
|
*prog=exec_finish(spawn);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2001-12-15 19:27:13 +01:00
|
|
|
static int
|
|
|
|
keyserver_work(int action,STRLIST list,u32 (*kidlist)[2],int count)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
2001-12-22 00:06:02 +01:00
|
|
|
int rc=0,ret=0;
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
if(opt.keyserver_scheme==NULL ||
|
|
|
|
opt.keyserver_host==NULL ||
|
|
|
|
opt.keyserver_port==NULL)
|
|
|
|
{
|
|
|
|
log_error(_("no keyserver known (use option --keyserver)\n"));
|
|
|
|
return G10ERR_BAD_URI;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Use the internal HKP code */
|
|
|
|
if(strcasecmp(opt.keyserver_scheme,"x-hkp")==0 ||
|
|
|
|
strcasecmp(opt.keyserver_scheme,"hkp")==0 ||
|
|
|
|
strcasecmp(opt.keyserver_scheme,"x-broken-hkp")==0)
|
|
|
|
{
|
|
|
|
void *stats_handle = import_new_stats_handle ();
|
|
|
|
|
|
|
|
switch(action)
|
|
|
|
{
|
|
|
|
case GET:
|
|
|
|
for(count--;count>=0;count--)
|
|
|
|
if(hkp_ask_import(kidlist[count],stats_handle))
|
|
|
|
log_inc_errorcount();
|
|
|
|
break;
|
|
|
|
case SEND:
|
|
|
|
return hkp_export(list);
|
|
|
|
case SEARCH:
|
|
|
|
return hkp_search(list);
|
|
|
|
}
|
|
|
|
|
|
|
|
import_print_stats (stats_handle);
|
|
|
|
import_release_stats_handle (stats_handle);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* It's not the internal HKP code, so try and spawn a handler for it */
|
|
|
|
|
2001-12-27 21:48:05 +01:00
|
|
|
rc=keyserver_spawn(action,list,kidlist,count,&ret);
|
|
|
|
if(ret)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
2001-12-22 00:06:02 +01:00
|
|
|
switch(ret)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
case KEYSERVER_SCHEME_NOT_FOUND:
|
2001-12-17 23:48:52 +01:00
|
|
|
log_error(_("no handler for keyserver scheme \"%s\"\n"),
|
2001-12-06 22:54:04 +01:00
|
|
|
opt.keyserver_scheme);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KEYSERVER_INTERNAL_ERROR:
|
|
|
|
default:
|
2001-12-17 23:48:52 +01:00
|
|
|
log_error(_("keyserver internal error\n"));
|
2001-12-06 22:54:04 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2001-12-27 21:48:05 +01:00
|
|
|
return G10ERR_KEYSERVER;
|
2001-12-06 22:54:04 +01:00
|
|
|
}
|
2001-12-27 21:48:05 +01:00
|
|
|
|
|
|
|
if(rc)
|
2001-12-22 00:06:02 +01:00
|
|
|
{
|
2001-12-27 21:48:05 +01:00
|
|
|
log_error(_("keyserver communications error: %s\n"),g10_errstr(rc));
|
2001-12-22 00:06:02 +01:00
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-12-15 19:27:13 +01:00
|
|
|
int
|
|
|
|
keyserver_export(STRLIST users)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
return keyserver_work(SEND,users,NULL,0);
|
|
|
|
}
|
|
|
|
|
2001-12-15 19:27:13 +01:00
|
|
|
int
|
|
|
|
keyserver_import(STRLIST users)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
u32 (*kidlist)[2];
|
|
|
|
int num=100,count=0;
|
|
|
|
int rc=0;
|
|
|
|
|
|
|
|
/* Build a list of key ids */
|
|
|
|
|
|
|
|
kidlist=m_alloc(sizeof(u32)*2*num);
|
|
|
|
|
|
|
|
for(;users;users=users->next)
|
|
|
|
{
|
|
|
|
KEYDB_SEARCH_DESC desc;
|
|
|
|
|
|
|
|
classify_user_id (users->d, &desc);
|
|
|
|
if(desc.mode==KEYDB_SEARCH_MODE_SHORT_KID ||
|
|
|
|
desc.mode==KEYDB_SEARCH_MODE_LONG_KID)
|
|
|
|
{
|
|
|
|
kidlist[count][0]=desc.u.kid[0];
|
|
|
|
kidlist[count][1]=desc.u.kid[1];
|
|
|
|
count++;
|
|
|
|
if(count==num)
|
|
|
|
{
|
|
|
|
num+=100;
|
|
|
|
kidlist=m_realloc(kidlist,sizeof(u32)*2*num);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2001-12-17 23:48:52 +01:00
|
|
|
log_error (_("skipping invalid key ID \"%s\"\n"), users->d );
|
2001-12-06 22:54:04 +01:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(count>0)
|
|
|
|
rc=keyserver_work(GET,NULL,kidlist,count);
|
|
|
|
|
|
|
|
m_free(kidlist);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2001-12-15 19:27:13 +01:00
|
|
|
int
|
|
|
|
keyserver_import_keyid(u32 *keyid)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
STRLIST sl=NULL;
|
|
|
|
char key[17];
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
sprintf(key,"%08lX%08lX",(ulong)keyid[0],(ulong)keyid[1]);
|
|
|
|
|
|
|
|
add_to_strlist(&sl,key);
|
|
|
|
|
|
|
|
ret=keyserver_import(sl);
|
|
|
|
|
|
|
|
free_strlist(sl);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* code mostly stolen from do_export_stream */
|
2001-12-15 19:27:13 +01:00
|
|
|
static int
|
|
|
|
keyidlist(STRLIST users,u32 (**kidlist)[2],int *count)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
int rc=0,ndesc,num=100;
|
|
|
|
KBNODE keyblock=NULL,node;
|
|
|
|
KEYDB_HANDLE kdbhd;
|
|
|
|
KEYDB_SEARCH_DESC *desc;
|
|
|
|
STRLIST sl;
|
|
|
|
|
|
|
|
*count=0;
|
|
|
|
|
|
|
|
*kidlist=m_alloc(sizeof(u32)*2*num);
|
|
|
|
|
|
|
|
kdbhd=keydb_new(0);
|
|
|
|
|
|
|
|
if(!users)
|
|
|
|
{
|
|
|
|
ndesc = 1;
|
|
|
|
desc = m_alloc_clear ( ndesc * sizeof *desc);
|
|
|
|
desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++)
|
|
|
|
;
|
|
|
|
desc = m_alloc ( ndesc * sizeof *desc);
|
|
|
|
|
|
|
|
for (ndesc=0, sl=users; sl; sl = sl->next)
|
|
|
|
{
|
|
|
|
if(classify_user_id (sl->d, desc+ndesc))
|
|
|
|
ndesc++;
|
|
|
|
else
|
|
|
|
log_error (_("key `%s' not found: %s\n"),
|
|
|
|
sl->d, g10_errstr (G10ERR_INV_USER_ID));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!(rc = keydb_search (kdbhd, desc, ndesc)))
|
|
|
|
{
|
|
|
|
if (!users)
|
|
|
|
desc[0].mode = KEYDB_SEARCH_MODE_NEXT;
|
|
|
|
|
|
|
|
/* read the keyblock */
|
|
|
|
rc = keydb_get_keyblock (kdbhd, &keyblock );
|
|
|
|
if( rc )
|
|
|
|
{
|
|
|
|
log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
|
|
|
|
goto leave;
|
|
|
|
}
|
|
|
|
|
|
|
|
if((node=find_kbnode(keyblock,PKT_PUBLIC_KEY)))
|
|
|
|
{
|
|
|
|
keyid_from_pk(node->pkt->pkt.public_key,(*kidlist)[*count]);
|
|
|
|
|
|
|
|
(*count)++;
|
|
|
|
|
|
|
|
if(*count==num)
|
|
|
|
{
|
|
|
|
num+=100;
|
|
|
|
*kidlist=m_realloc(*kidlist,sizeof(u32)*2*num);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( rc == -1 )
|
|
|
|
rc = 0;
|
|
|
|
|
|
|
|
leave:
|
|
|
|
keydb_release(kdbhd);
|
|
|
|
release_kbnode(keyblock);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Note this is different than the original HKP refresh. It allows
|
|
|
|
usernames to refresh only part of the keyring. */
|
|
|
|
|
2001-12-15 19:27:13 +01:00
|
|
|
int
|
|
|
|
keyserver_refresh(STRLIST users)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
u32 (*kidlist)[2];
|
|
|
|
int count;
|
|
|
|
|
|
|
|
rc=keyidlist(users,&kidlist,&count);
|
|
|
|
if(rc)
|
|
|
|
return rc;
|
|
|
|
|
2001-12-17 23:48:52 +01:00
|
|
|
if(count==1)
|
|
|
|
log_info(_("%d key to refresh\n"),count);
|
|
|
|
else
|
|
|
|
log_info(_("%d keys to refresh\n"),count);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
if(count>0)
|
|
|
|
rc=keyserver_work(GET,NULL,kidlist,count);
|
|
|
|
|
|
|
|
m_free(kidlist);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-12-15 19:27:13 +01:00
|
|
|
int
|
|
|
|
keyserver_search(STRLIST tokens)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
if(tokens)
|
|
|
|
return keyserver_work(SEARCH,tokens,NULL,0);
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Count is just for cosmetics. If it is too small, it will grow
|
2001-12-28 17:34:01 +01:00
|
|
|
safely. If negative it disables the "Key x-y of z" messages. */
|
2001-12-15 19:27:13 +01:00
|
|
|
void
|
|
|
|
keyserver_search_prompt(IOBUF buffer,int count,const char *searchstr)
|
2001-12-06 22:54:04 +01:00
|
|
|
{
|
|
|
|
int i=0,validcount=1;
|
|
|
|
unsigned int maxlen=256,buflen=0;
|
|
|
|
u32 (*keyids)[2];
|
|
|
|
byte *line=NULL;
|
|
|
|
char *answer;
|
|
|
|
|
|
|
|
if(count==0)
|
|
|
|
{
|
|
|
|
if(searchstr)
|
2001-12-17 23:48:52 +01:00
|
|
|
log_info(_("key \"%s\" not found on keyserver\n"),searchstr);
|
2001-12-06 22:54:04 +01:00
|
|
|
else
|
2001-12-17 23:48:52 +01:00
|
|
|
log_info(_("key not found on keyserver\n"));
|
2001-12-06 22:54:04 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(count<0)
|
|
|
|
{
|
|
|
|
validcount=0;
|
|
|
|
count=1;
|
|
|
|
}
|
|
|
|
|
|
|
|
keyids=m_alloc(count*sizeof(u32)*2);
|
|
|
|
|
|
|
|
/* Read each line and show it to the user */
|
|
|
|
|
|
|
|
for(;;)
|
|
|
|
{
|
|
|
|
int rl;
|
|
|
|
|
|
|
|
if(i==count)
|
|
|
|
{
|
|
|
|
count++;
|
|
|
|
keyids=m_realloc(keyids,count*sizeof(u32)*2);
|
|
|
|
validcount=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
i++;
|
|
|
|
|
|
|
|
if(validcount && (i-1)%10==0)
|
|
|
|
{
|
|
|
|
printf("Keys %d-%d of %d",i,(i+9<count)?i+9:count,count);
|
|
|
|
printf(" for \"%s\"",searchstr);
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
maxlen=1024;
|
|
|
|
rl=iobuf_read_line(buffer,&line,&buflen,&maxlen);
|
|
|
|
if(rl>0)
|
|
|
|
{
|
|
|
|
if(print_keyinfo(i,line,keyids[i-1]))
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
i--;
|
|
|
|
|
|
|
|
if(i%10==0 || rl==0)
|
|
|
|
{
|
|
|
|
answer=cpr_get_no_help("keysearch.prompt",
|
|
|
|
_("Enter number(s), N)ext, or Q)uit > "));
|
|
|
|
if(answer[0]=='q' || answer[0]=='Q')
|
|
|
|
{
|
|
|
|
m_free(answer);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else if(atoi(answer)>=1 && atoi(answer)<=i)
|
|
|
|
{
|
|
|
|
char *split=answer,*num;
|
|
|
|
|
|
|
|
while((num=strsep(&split," ,"))!=NULL)
|
|
|
|
if(atoi(num)>=1 && atoi(num)<=i)
|
2002-01-03 21:03:14 +01:00
|
|
|
keyserver_work(GET,NULL,&keyids[atoi(num)-1],1);
|
2001-12-06 22:54:04 +01:00
|
|
|
|
|
|
|
m_free(answer);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
m_free(keyids);
|
|
|
|
m_free(line);
|
|
|
|
}
|