1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// -*- mode: cpp; mode: fold -*-
// Include Files /*{{{*/
#include<config.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <vector>
#include <apt-pkg/error.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/fileutl.h>
#include <apt-pkg/configuration.h>
#include <apti18n.h>
/*}}}*/
using namespace std;
// RunGPGV - returns the command needed for verify /*{{{*/
// ---------------------------------------------------------------------
/* Generating the commandline for calling gpgv is somehow complicated as
we need to add multiple keyrings and user supplied options. */
void ExecGPGV(std::string const &File, std::string const &FileGPG,
int const &statusfd, int fd[2])
{
#define EINTERNAL 111
if (File == FileGPG)
{
#define SIGMSG "-----BEGIN PGP SIGNED MESSAGE-----\n"
char buffer[sizeof(SIGMSG)];
FILE* gpg = fopen(File.c_str(), "r");
if (gpg == NULL)
{
ioprintf(std::cerr, _("Could not open file %s"), File.c_str());
exit(EINTERNAL);
}
char const * const test = fgets(buffer, sizeof(buffer), gpg);
fclose(gpg);
if (test == NULL || strcmp(buffer, SIGMSG) != 0)
{
ioprintf(std::cerr, _("File %s doesn't start with a clearsigned message"), File.c_str());
exit(EINTERNAL);
}
#undef SIGMSG
}
string const gpgvpath = _config->Find("Dir::Bin::gpg", "/usr/bin/gpgv");
// FIXME: remove support for deprecated APT::GPGV setting
string const trustedFile = _config->Find("APT::GPGV::TrustedKeyring", _config->FindFile("Dir::Etc::Trusted"));
string const trustedPath = _config->FindDir("Dir::Etc::TrustedParts");
bool const Debug = _config->FindB("Debug::Acquire::gpgv", false);
if (Debug == true)
{
std::clog << "gpgv path: " << gpgvpath << std::endl;
std::clog << "Keyring file: " << trustedFile << std::endl;
std::clog << "Keyring path: " << trustedPath << std::endl;
}
std::vector<string> keyrings;
if (DirectoryExists(trustedPath))
keyrings = GetListOfFilesInDir(trustedPath, "gpg", false, true);
if (RealFileExists(trustedFile) == true)
keyrings.push_back(trustedFile);
std::vector<const char *> Args;
Args.reserve(30);
if (keyrings.empty() == true)
{
// TRANSLATOR: %s is the trusted keyring parts directory
ioprintf(std::cerr, _("No keyring installed in %s."),
_config->FindDir("Dir::Etc::TrustedParts").c_str());
exit(EINTERNAL);
}
Args.push_back(gpgvpath.c_str());
Args.push_back("--ignore-time-conflict");
char statusfdstr[10];
if (statusfd != -1)
{
Args.push_back("--status-fd");
snprintf(statusfdstr, sizeof(fd), "%i", statusfd);
Args.push_back(statusfdstr);
}
for (vector<string>::const_iterator K = keyrings.begin();
K != keyrings.end(); ++K)
{
Args.push_back("--keyring");
Args.push_back(K->c_str());
}
Configuration::Item const *Opts;
Opts = _config->Tree("Acquire::gpgv::Options");
if (Opts != 0)
{
Opts = Opts->Child;
for (; Opts != 0; Opts = Opts->Next)
{
if (Opts->Value.empty() == true)
continue;
Args.push_back(Opts->Value.c_str());
}
}
Args.push_back(FileGPG.c_str());
if (FileGPG != File)
Args.push_back(File.c_str());
Args.push_back(NULL);
if (Debug == true)
{
std::clog << "Preparing to exec: " << gpgvpath;
for (std::vector<const char *>::const_iterator a = Args.begin(); *a != NULL; ++a)
std::clog << " " << *a;
std::clog << std::endl;
}
if (statusfd != -1)
{
int const nullfd = open("/dev/null", O_RDONLY);
close(fd[0]);
// Redirect output to /dev/null; we read from the status fd
if (statusfd != STDOUT_FILENO)
dup2(nullfd, STDOUT_FILENO);
if (statusfd != STDERR_FILENO)
dup2(nullfd, STDERR_FILENO);
// Redirect the pipe to the status fd (3)
dup2(fd[1], statusfd);
putenv((char *)"LANG=");
putenv((char *)"LC_ALL=");
putenv((char *)"LC_MESSAGES=");
}
execvp(gpgvpath.c_str(), (char **) &Args[0]);
ioprintf(std::cerr, "Couldn't execute %s to check %s", Args[0], File.c_str());
exit(EINTERNAL);
}
/*}}}*/
|
